notebooks/aula1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 1. Estruturas de dados Fundamentais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesta aula conheceremos as principais estruturas de dados nativas da linguagem *Python*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Conteúdos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [1. Tipos básicos](#1.-Tipos-básicos)\n",
    "    * [Representando informação numérica com *Integer* e *Float*](#Representando-informação-numérica-com-os-tipos-Integer-e-Float)\n",
    "    * [Representando informação textual com *Strings*](#Representando-informação-textual-com-Strings)\n",
    "    * [Representando valores lógicos com *Boolean*](#Representando-valores-lógicos-com-Boolean)\n",
    "    \n",
    "* [2. Tipos compostos](#2.-Tipos-compostos)\n",
    "    * [Listas](#Listas)\n",
    "    * [Tuplas](#Tuplas)\n",
    "    * [Dicionários](#Dicionários)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Tipos básicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Representamos informação usando um conjunto de **tipos** básicos, fornecidos pela linguagem. São eles:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Tipo|Desc|Exemplo||\n",
    "|----|--|--|\n",
    "|Integer (`int`)|Permite representar informação numérica (números inteiros)| `42` |\n",
    "|Float (`float`)|Permite representar informação numérica, com casas decimais | `42.0` |\n",
    "|String (`str`)|Permite representar informação textual | `\"Hello World\"` |\n",
    "|Boolean (`bool`)|Permite representar valores lógicos (lógica booleana) | `True` ou `False` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a seguir estudar cada um destes tipos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Representando informação numérica com os tipos *Integer* e *Float*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma sequência de dígitos é interpretada como um **número inteiro** (tipo `int`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Números reais** com casas decimais são representados usando o sistema de **ponto flutuante** (tipo `float`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.567"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.567"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dica:** Para consultar o tipo de um determinado valor, podemos usar a função nativa `type`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(42.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### Operações aritméticas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "O interpretador *Python* permite operar valores numéricos usando um conjunto de operadores aritméticos pré-definidos.\n",
    "As operações usadas mais frequentemente são:\n",
    "\n",
    "| Operação| Operador| Exemplo | Resultado\n",
    "|:-|---|-:|--|\n",
    "| Adição      | `+` | `9 + 7` | `16` |\n",
    "| Subtração | `-` | `9 - 7` | `2` |\n",
    "| Multiplicação | `*` | `9 * 7` | `63` |\n",
    "| Divisão | `/` | `5 / 2`| `2.5` | \n",
    "| Divisão inteira | `//` | `5 // 2` | `2` |\n",
    "| Exponenciação | `**` | `9**2` | `81` |\n",
    "| Módulo | `%` | `9 % 2` | `1` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**Regra 1**: Operações envolvendo apenas números inteiros resultam em números inteiros (com exceção da divisão)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "37"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 - 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "210"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 % 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "A operação de divisão é a exceção à regra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42/5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Mas podemos utilizar o operador de divisão inteira (`//`), que descarta a parte decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "41//5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**Regra 2**: Operações envolvendo pelo menos um número de ponto flutuante resultam em números de ponto flutuante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.0 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "37.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 - 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "210.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 * 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 ** 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.0 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.0 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "41.0 // 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### Comparando valores numéricos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Podemos comparar valores numéricos usando os **operadores de comparação**. Estes operadores avaliam se a expressão é verdadeira, retornando valores lógicos `True` ou `False` (mais sobre valores lógicos a seguir)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "| Operador | Descrição |\n",
    "| - | - |\n",
    "|    `==`  | Retorna `True` se valores de dois operandos são iguais |\n",
    "|    `!=`  | Retorna `True` se valores de dois operandos são diferentes |\n",
    "|    `<`  | Retorna `True` se valor do operando à esquerda é menor que o da direita |\n",
    "|    `<=`  | Retorna `True` se valor do operando à esquerda é menor ou igual ao da direita|\n",
    "|    `>`  | Retorna `True` se valor do operando à esquerda é maior que o da direita |\n",
    "|    `>=`  | Retorna `True` se valor do operando à esquerda é maior ou igual ao da direita |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 != 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 <= 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 >= 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "\n",
    "Na comparação, o tipo utilizado para representar o valor não importa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.0 == 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.01 == 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Representando informação textual com *Strings*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings podem ser codificadas usando aspas duplas ou simples, desde que usadas de forma coerente: aspas duplas devem ser fechadas com aspas duplas, assim como aspas simples devem ser fechadas com aspas simples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'String criada com aspas duplas'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"String criada com aspas duplas\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'String criada com aspas simples'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'String criada com aspas simples'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usamos uma combinação de aspas simples e duplas quando queremos que elas sejam interpretadas como caracteres pertencentes à própria string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"String criada com aspas duplas, contendo texto com 'aspas simples'\""
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"String criada com aspas duplas, contendo texto com 'aspas simples'\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'String criada com aspas simples, contendo texto com \"aspas duplas\"'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'String criada com aspas simples, contendo texto com \"aspas duplas\"'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também usar triplas (3 aspas duplas ou 3 aspas simples) para criar strings com quebra de linha. Observe que a quebra de linha é codificada na string com um caractere especial, o *newline* (`'\\n'`). Mas as linhas só são de fato quebradas quando imprimimos a string no console, usando a função `print`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Aspas triplas permitem criar strings com múltiplas linhas.\\nCada quebra de linha é transformada no caractere especial 'newline'.\\nQuando a string é imprimida, o caractere especial 'newline' quebra a linha.\""
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Aspas triplas permitem criar strings com múltiplas linhas.\n",
    "Cada quebra de linha é transformada no caractere especial 'newline'.\n",
    "Quando a string é imprimida, o caractere especial 'newline' quebra a linha.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aspas triplas permitem criar strings com múltiplas linhas.\n",
      "Cada quebra de linha é transformada no caractere especial 'newline'.\n",
      "Quando a string é imprimida, o caractere especial 'newline' quebra a linha.\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"Aspas triplas permitem criar strings com múltiplas linhas.\n",
    "Cada quebra de linha é transformada no caractere especial 'newline'.\n",
    "Quando a string é imprimida, o caractere especial 'newline' quebra a linha.\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas e se quiséssemos de fato armazenar os caracteres `'\\'` e `'n'` na string, sem que fossem interpretados como um caractere especial? Neste desvemos usar um outro caractere especial, o *escape character* (`'\\'`). Sempre que usamos este caractere dizemos que o caractere seguinte não deve ser interpretado como caractere especial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Se quisermos pular uma linha é só usar o caractere 'newline'.\n",
      "Ele é considerado um caractere especial.\n"
     ]
    }
   ],
   "source": [
    "print(\"Se quisermos pular uma linha é só usar o caractere 'newline'.\\nEle é considerado um caractere especial.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E se quisermos incluir os dois caracteres `\\`e `n` literalmente na string? Podemos usar um *backslash* (`\\`) para escapar o caractere especial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Se quisermos pular uma linha é só usar o caractere 'newline' (\\n).\n",
      "Ele é considerado um caractere especial.\n"
     ]
    }
   ],
   "source": [
    "print(\"Se quisermos pular uma linha é só usar o caractere 'newline' (\\\\n).\\nEle é considerado um caractere especial.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings cruas (*raw strings*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se quisermos escapar todos os caracteres especiais, podemos dizer que uma string é \"crua\", (uma *raw string*). Para isso, basta adicionar o caractere `'r'` imediatamente antes de abrir a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Esta é uma string crua.\\\\nCaracteres especiais são automaticamente escapados, e interpretados literalmente'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r\"Esta é uma string crua.\\nCaracteres especiais são automaticamente escapados, e interpretados literalmente\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta é uma string crua.\\nCaracteres especiais são automaticamente escapados, e interpretados literalmente\n"
     ]
    }
   ],
   "source": [
    "print(r\"Esta é uma string crua.\\nCaracteres especiais são automaticamente escapados, e interpretados literalmente\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta NÃO é uma string crua.\n",
      "Caracteres especiais NÃO são escapados, e exercem sua função esperada\n"
     ]
    }
   ],
   "source": [
    "print(\"Esta NÃO é uma string crua.\\nCaracteres especiais NÃO são escapados, e exercem sua função esperada\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatação de Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A linguagem oferece divermas maneiras para formatar strings, usando valores contidos em variáveis ou resultantes de expressões avaliadas em tempo de execução. Aqui vamos conhecer apenas os dois mais comumente usados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### O método `.format()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este método realiza a formatação da string inserindo entre as chaves (também chamados \"campos de substituição\") os valores que são passados como argumento. Caso os campos de substituição estejam vazios, a substituição dos valores ocorre na mesma ordem em que são passados para a função `format`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is Luke Skywalker. I am 28 years old'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"My name is {}. I am {} years old\".format(\"Luke Skywalker\", 18 + 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Campos de substituição podem incluir o índice (posição) do argumento que deve ser substituído"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is Luke Skywalker. I am Luke Skywalker years old'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"My name is {0}. I am {0} years old\".format(\"Luke Skywalker\", 18 + 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is 28. I am Luke Skywalker years old'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"My name is {1}. I am {0} years old\".format(\"Luke Skywalker\", 18 + 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso a função `format` receba argumentos nomeados, podemos usar os nomes nos campos de substituição"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is Luke Skywalker. I am 28 years old'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"My name is {name}. I am {age} years old\".format(name=\"Luke Skywalker\", age=18 + 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais detalhes sobre o método `format` estão documentados [aqui](https://docs.python.org/3/library/stdtypes.html#str.format)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### As f-strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir do *Python 3.6*, a formatação de strings ficou ainda mais simples com as **f-strings** (ou *\"formatted string literals\"*). Para construir uma f-string, devemos *(i)* adicionar o caractere `'f'` imediatamente antes de abrir a string; e *(ii)* usar chaves (`{}`) para conter expressões cujos valores deverão ser substituídos. \n",
    "Veja o exemplo abaixo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is Luke Skywalker. I am 28 years old'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myName = \"Luke Skywalker\"\n",
    "age = 18 + 10\n",
    "\n",
    "f\"My name is {myName}. I am {age} years old\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Atualmente este é o método de formatação mais indicado pela comunidade *Python*. Veja mais detalhes na [documentação](https://docs.python.org/3/reference/lexical_analysis.html#f-strings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Representando valores lógicos com *Boolean*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na [álgebra booleana](https://www.wikiwand.com/en/Boolean_algebra), variáveis podem assumir apenas dois valores distintos: \"verdadeiro\" (`True`) ou \"falso\" (`True`). Na linguagem *Python*, estes elementos lógicos são representados com o tipo *Boolean* (`bool`). Operadores de comparação envolvendo números resultam em valores lógicos. O uso de expressões lógicas é muito comum quando construímos **estruturas de decisão** no nosso programa, como veremos adiante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na álgebra booleana, são definidas três operações fundamentais: a **conjunção** (`and`), a **disjunção** (`or`), e a **negação** (`not`). Podemos construir expressões a partir destes operadores, e avaliar seu valor lógico, usando como base uma tabela-verdade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|X|Y|X and Y|X or Y| not X\n",
    "|-|-|-|\n",
    "|`False`| `False`| `False`|`False`|`True`|\n",
    "|`False`| `True` | `False`|`True` |`True`|\n",
    "|`True` | `False`| `False`|`True` |`False`|\n",
    "|`True` | `True` | `True` |`True` |`False`|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando as expressões se tornam mais complexas, podemos indicar a ordem de avaliação das operações usando parênteses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(True and False) and (True and not False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(not False) and (not(not True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valores lógicos também resultam de operações de comparação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 10 == 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 11 == 18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "20 >= 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 >= 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 10 == 15 or 5 + 11 ==18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5 > 10) or (5 <=5) and not(10==12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O interpretador *Python* considera que números diferentes do zero possuem valor lógico `True`, enquanto o zero possui valor lógico `False`. Podemos então operar valores numéricos com operadores lógicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**obs**: A função `bool` converte valores de tipos não-booleanos para booleanos (coerção de tipos, ou type casting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1 and 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(2 and 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1 and 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1 or 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1 and not 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings também podem assumir valores lógicos. Neste caso, strings de comprimento maior que 0 equivalem a `True`, enquanto strings de comprimento igual a zero equivalem a `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strings de comprimento > 0 equivalem a True\n",
    "bool(\"texto\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strings de comprimento 0 equivalem a False\n",
    "bool(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(\"Uma string\" and 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(\"Uma string\" and \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Tipos compostos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tipos compostos permitem armazenar conjuntos de valores em uma única estrutura."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listas são representadas pelo tipo `list`. Cada elemento ocupando uma posição dentro da lista é chamado de **item**. O número de itens que uma lista armazena é referido como seu **comprimento**. A princípio não há limites para o comprimento de uma lista, embora listas grandes demais certamente exigem mais recursos computacionais, podendo se tornar intratáveis. Uma característica importante das listas é que elas permitem armazenar itens de tipos diferentes dentro de uma mesma estrutura (embora seja mais usual armazenar itens do mesmo tipo). Podemos por exemplo armazenar dentro de uma única lista *strings*, *booleanos*, *inteiros*, *floats*, e até outras *listas*!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/lists.png\" width=400/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na ilustração acima, temos uma lista de comprimento 5, armazenando itens de tipos diferentes. \n",
    "Cada item da lista ocupa um espaço próprio, representado como um \"quadradinho\". Os números abaixo de cada quadrado representam os **índices** de cada item na lista. Os índices nada mais são que endereços numéricos, que nos permitem referenciar elementos em cada posição na lista. Por exemplo, se quisermos nos referir ao número 42, indicaremos o índice (ou endereço) 2.\n",
    "\n",
    "**Obs:** Em *Python*, a numeração dos índices começa em zero, e portanto o primeiro elemento se encontra na posição 0. Da mesma forma, o último item de uma lista de comprimento $n$ se encontra na posição $n-1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criando listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos criar uma lista vazia apenas abrindo e fechando colchetes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou usando a função `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos adicionar elementos a uma lista já existente usando o método `append`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['el1', 'el2']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = list()\n",
    "l.append('el1')\n",
    "l.append('el2')\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e remover elementos usando o método `remove`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['el2']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.remove('el1')\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos criar uma lista pré-populada, inserindo os elementos nela contidos entre colchetes, separados por vírgulas. Note que a ordem dos itens permanece a mesma em que foram inseridos durante a criação da lista. Vamos criar a lista dad como exemplo na figura acima"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Olá', True, 42, 9.87, ['a', 'b', 'c']]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ \"Olá\", True, 42, 9.87, ['a','b','c']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também criar uma lista contendo uma sequência de números inteiros (uma *range*), que é criada usando as funções `list` e `range`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Obs 1**: Perceba que para efetivamente criar a lista passamos o resultado da função `range` para a função `list`. Isso ocorre porque a função `range` cria um objeto que sabe como produzir a sequência de números, mas não o faz automaticamente.\n",
    "\n",
    "**Obs 2**: A função `range` cria uma sequência de números de 0 a $n-1$, caso apenas um argumento, com valor $n$, seja fornecido. Consulte a documentação da função para ver outras formas de criar uma sequência."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list( range(10) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compreensão de Listas (List comprehension)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O método de [**compreensão de listas**](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) permite criar listas dinamicamente, usando uma expressão. É portanto uma forma mais eficiente e concisa de se criar listas em *Python*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este método usa a seguinte sintaxe:\n",
    "```python\n",
    "[ expressão(item) for item in lista if condição(item) ]\n",
    "```\n",
    "\n",
    "sendo \n",
    "* `lista`: uma lista pré-existente, ou objeto a ser iterado;\n",
    "* `item`: a variável de iteração;\n",
    "* `expressão`: uma expressão que pode usar o valor em `item`;\n",
    "* `condição` (opcional): o resultado da expressão só é incluído na lista final caso a avaliação da condição resulte em `True`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por exemplo, podemos criar uma lista contendo os quadrados dos números de 1 a 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ x**2 for x in range(1,11) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou os quadrados dos números pares de 1 a 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 16, 36, 64, 100, 144, 196, 256, 324, 400]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ x**2 for x in range(1,21) if x%2==0 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou até mesmo uma lista contendo listas de comprimento 2.\n",
    "Cada lista interna armazena um número par entre 1 e 20 e seu quadrado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 4],\n",
       " [4, 16],\n",
       " [6, 36],\n",
       " [8, 64],\n",
       " [10, 100],\n",
       " [12, 144],\n",
       " [14, 196],\n",
       " [16, 256],\n",
       " [18, 324],\n",
       " [20, 400]]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ [x,x**2] for x in range(1,21) if x%2==0 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando o exemplo acima, podemos criar uma lista de strings formatadas com os números e seus quadrados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2^2 = 4',\n",
       " '4^2 = 16',\n",
       " '6^2 = 36',\n",
       " '8^2 = 64',\n",
       " '10^2 = 100',\n",
       " '12^2 = 144',\n",
       " '14^2 = 196',\n",
       " '16^2 = 256',\n",
       " '18^2 = 324',\n",
       " '20^2 = 400']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ f\"{x}^2 = {x**2}\" for x in range(1,21) if x%2==0 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O método de compreensão de listas fornece à linguagem *Python* um grande ganho em expressividade. Podemos criar listas a partir de expressões relativamente complexas em apenas uma linha!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Acessando elementos em uma lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que temos uma lista, como acessar os elementos dentro dela? Existem basicamente duas formas: a indexação (**indexing**) e o recorte (**slicing**). Por fim, podemos usar também algumas funções aplicáveis a listas. Vejamos cada um deles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando a **notação de indexação** `[i]` podemos recuperar o elemento em determinada posição em uma lista. Para isso basta indicar o índice `i` do elemento que queremos entre colchetes, ao lado da nossa lista (ou da variável que a armazena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "myList = ['a','b','c','d','e','f','g','h','i','j']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'j'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar números negativos para nos referir a elementos na lista seguindo uma lógica de ordem reversa. Por exemplo, podemos usar o índice -1 para nos referir ao último elemento, -2 ao penúltimo, e assim por diante.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'j'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'i'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[-10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se tentarmos passar um índice que não exista na lista (por exemplo o índice 10 em uma lista de comprimento 10), o interpretador encerrará a execução do programa e nos mostrará uma mensagem de erro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-94-bb7b0cf4a394>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "myList[10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também **atualizar** valores contidos na lista usando seu índice (posição na lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "myList[0] = 'A'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "myList[1] = 'B'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Usando a **notação de recorte** `[i:j]` podemos recuperar um conjunto de elementos de uma lista. A diferença para a indexação é que o recorte retorna uma sublista (um pedaço, ou *slice* da lista original), em vez de um único elemento. Para isso indicamos, entre colchetes e separados por dois pontos, dois números: o primeiro (`i`) é o índice do elemento no começo do recorte; o segundo (`j`) é o índice do elemento que delimita o fim do pedaço (não-inclusivo). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "myList = ['a','b','c','d','e','f','g','h','i','j']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['b', 'c', 'd', 'e', 'f']"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[1:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Podemos omitir o número `i` ou `j` se quisermos que o pedaço comece do primeiro elemento da lista ou que termine no último elemento da lista, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd', 'e', 'f']"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['e', 'f', 'g', 'h', 'i', 'j']"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[4:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Embora pouco usual, podemos definir o **passo** do recorte alterando a notação de recorte para `[i:j:k]`. Neste caso, `k` é o tamanho do passo, ou seja, o número de elementos que devem ser pulados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'e', 'g']"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[2:8:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'c', 'e', 'g']"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[:8:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'e', 'g', 'i']"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[2::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'c', 'e', 'g', 'i']"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### Funções aplicáveis a listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Existem algumas funções permitem obter elementos com características específicas de uma lista. Por exemplo, poderíamos querer consultar quais os elemento com maior e menor valor dentro da lista. Para isso, podemos usar as funções `max` e `min`, respectivamente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "myList = [1,3,10,-4,12,7,42,-3,0,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(myList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "E se precisarmos usar a lista em ordem inversa? A função `reversed` espera receber uma lista e retorna um objeto iterador, que pode ser interpretado como uma cópia da lista original porém com os elementos em ordem inversa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<list_reverseiterator at 0x7f4157779278>"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reversed(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, -3, 42, 7, 12, -4, 10, 3, 1]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(reversed(myList))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Finalmente, podemos verificar se um elemento com determinado valor existe dentro de uma lista. Para isso, construímos uma expressão utilizando o operador `in`. Caso o elemento exista na lista, a expressão retornará o valor booleano `True` e, caso contrário, `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 in myList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-42 in myList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combinando listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível construir listas facilmente a partir de outras. Para isso usamos o operador `+`, que pode ser usado para concatenar listas. \n",
    "**obs**: Listas só podem ser somadas a listas! Portanto é fundamental que ambos os operandos sejam listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 1, 2, 3, True, False]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a','b','c'] + [1, 2, 3] + [True, False]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 42, 43]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista1 = ['a','b']\n",
    "lista2 = [42, 43]\n",
    "\n",
    "lista1 + lista2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Emparelhando listas com a função *Zip*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função `zip` emparelha duas ou mais listas (ou outros elementos iteráveis), retornando um iterador (*zip object*) com o mesmo comprimento do menor dos iterávei usados para construí-lo. \n",
    "Porém, usualmente aplicamos a função a iteráveis de mesmo comprimento.\n",
    "Cada elemento dentro do iterador *zip* é uma n-tupla, sendo n o número de iteráveis passados para a função"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos emparelhar duas listas de mesmo comprimento. Como ela retorna um [iterador](https://docs.python.org/3/library/stdtypes.html#typeiter), precisamos usar a função `list` caso queiramos que o resultado seja convertido em uma lista "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a'), (7, 'b'), (4, 'c'), (0, 'd'), (3, 'e')]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [  1,    7,   4,   0,   3 ]\n",
    "l2 = [ 'a', 'b', 'c', 'd', 'e' ]\n",
    "\n",
    "list( zip(l1,l2) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou de comprimentos diferentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a'), (7, 'b'), (4, 'c')]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [  1,    7,   4,   0,   3 ]\n",
    "l2 = [ 'a', 'b', 'c' ]\n",
    "\n",
    "list( zip(l1,l2) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos emparelhar mais que apenas duas listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a', 'v'), (7, 'b', 'w'), (4, 'c', 'x'), (0, 'd', 'y'), (3, 'e', 'z')]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [  1,    7,   4,   0,   3 ]\n",
    "l2 = [ 'a', 'b', 'c', 'd', 'e' ]\n",
    "l3 = [ 'v', 'w', 'x', 'y', 'z' ]\n",
    "\n",
    "list( zip(l1,l2,l3) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Tuplas são representadas pelo tipo `tuple`, e armazenam conjuntos ordenados de valores. \n",
    "Portanto, assim como nas listas, a ordenação dos valores importa.\n",
    "A principal característica das tuplas que as diferencia das listas é que tuplas são **imutáveis**.\n",
    "Isso significa que não é possível adicionar ou remover elementos após sua criação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Criando tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "A criação de tuplas é bastante similar à criação de listas. Porém, todos os elementos que a compõem devem ser inseridos durante sua criação.\n",
    "Para isso, ordenamos os $n$ valores a compor a n-tupla entre parênteses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Tupla com apenas 1 elemento (1-tupla):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('el1',)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('el1',)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Par ordenado (2-tupla):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('el1', 'el2')"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('el1','el2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Tripla ordenada (3-tupla):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('el1', 'el2', 'el3')"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('el1','el2','el3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "e assim por diante..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Podemos também usar a função `tuple` para converter uma lista (ou objeto iterável) em uma tupla. Podemos por exemplo criar uma 5-tupla com números de 0 a 4 usando a função `range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 2, 3, 4)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(range(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ou transformar uma lista em uma tupla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Luke', 'Skywalker', 28, 'Jedi')"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [\"Luke\", \"Skywalker\", 28, \"Jedi\"]\n",
    "tuple( l )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Acessando elementos em uma tupla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ou at"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "A notação usada pra acessar elementos em uma tupla é idêntica à de listas. Usamos um índice posicional, que varia de $0$ a $n-1$, para uma tupla de comprimento $n$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Combinando tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Assim como em listas, podemos combinar tuplas usando o operador `+`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 2, 3, 'a', 'b', 'c', 'd')"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0,1,2,3) + ('a','b','c','d')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Atualizando tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Tuplas são **imutáveis**, portanto NÃO podem ser atualizadas.\n",
    "Mas em alguns casos podemos simular uma atualização criando novas tuplas tomando como base tuplas pré-existentes.\n",
    "Considere a tupla-base abaixo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "tupla_base = (0,1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "##### \"Adicionando\" um novo elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Podemos criar uma nova tupla contendo todos os elementos da tupla-base mais um novo elemento. Neste caso fazemos uma combinação de tuplas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 2, 3, 4)"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = tupla_base + (4,)\n",
    "t1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "##### \"Removendo\" o último elemento\n",
    "Podemos criar uma nova tupla contendo todos os elementos da tupla-base exceto o último"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 2)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = tupla_base[:-1]\n",
    "t1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dicionários são representados pelo tipo `dict` e, assim como listas e tuplas, são estruturas de dados que permitem armazenar conjuntos de valores. A principal diferença é que os valores são **indexados explicitamente** e **não são ordenados**.\n",
    "Dicionários possuem **chaves** (*keys*), que referenciam os **valores** (*values*) armazenados em memória.\n",
    "Dicionários são também conhecidos como *mapas* ou *índices*.\n",
    "\n",
    "**Obs 1**: As chaves não precisam ser necessariamente numéricas, podendo ser usado qualquer objeto \"hasheável\" ([*hashable*](https://docs.python.org/3/glossary.html)). Podem ser chaves, por exemplo, valores dos tipos *int*, *float*, *string*, *boolean* ou tuplas. Já listas e dicionários não podem ser usados como chaves. No entanto, normalmente criamos dicionários cujas chaves possuem o mesmo tipo.\n",
    "\n",
    "**Obs 2**: Cada chave deve ser única no dicionário e referenciar um único valor. Entretanto, um determinado valor pode ser referenciado por múltiplas chaves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/dicts.png\" width=250/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na ilustração acima, temos um dicionário composto por 5 chaves, que referenciam 4 valores distintos.\n",
    "Cada valor ocupa um espaço próprio na memória, representado como o retângulo que o contém.\n",
    "Diferentemente de listas, os índices **não são posicionais**, o que significa que é impossível resgatar elementos com base em sua posição no dicionário. Em vez disso usamos as chaves como índice para cada valor.\n",
    "Por exemplo, se quisermos resgatar o número 42, podemos indicar a chave `0` ou a chave `'k9'`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criando dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos criar um dicionário vazio simplesmente abrindo e fechando chaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou usando a função `dict`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos adicionar elementos a um dicionário já existente usando o método `update`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 'value1', 'key2': 'value2'}"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = dict()\n",
    "d.update( key1='value1',key2='value2' )\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e remover chaves e seus valores associados usando o método `pop`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key2': 'value2'}"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.pop('key1')\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entretanto, existe uma forma melhor de criar um dicionário pré-populado, caso já saibamos quais os elementos que o compõem.\n",
    "Para isso incluímos os pares chave-valor (`key:value`) entre chaves, separados de outros pares por vírgulas.\n",
    "Para indicar qual chave referencia cada valor, usamos dois pontos (`:`), seguindo a sintaxe abaixo\n",
    "\n",
    "```python\n",
    "{ k1:v1 , k2:v2 , ... , kn:vn }\n",
    "```\n",
    "\n",
    "sendo cada `k1`,`k2`, ..., `kn` chaves; e `v1`, `v2`, ..., `vn` seus valores associados. Vamos criar o dicionário dado como exemplo na figura acima"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{42: 'Olá', 'k1': True, 0: 42, 'k9': 42, -3: {'a': 1, 'b': 2}}"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ 42: \"Olá\", 'k1': True, 0: 42, 'k9':42, -3: {'a':1, 'b':2} }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para melhorar a legibilidade, podemos quebrar linhas enquanto criamos os dicionários, separando cada par chave-valor seguindo um nível de indentação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{42: 'Olá', 'k1': True, 0: 42, 'k9': 42, -3: {'a': 1, 'b': 2}}"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ 42: \"Olá\", \n",
    "  'k1': True, \n",
    "  0: 42, \n",
    "  'k9':42, \n",
    "  -3: { 'a':1, \n",
    "        'b':2 } \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também converter uma lista de 2-tuplas em um dicionário, usando a função `dict`. Neste caso, o primeiro elemento em cada tupla é interpretado como uma chave; e o segundo como seu valor associado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{42: 'Olá', 'k1': True, 0: 42, 'k9': 42, -3: {'a': 1, 'b': 2}}"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpls = [\n",
    "    (42, \"Olá\"),\n",
    "    ('k1', True),\n",
    "    (0, 42),\n",
    "    ('k9', 42),\n",
    "    (-3, {'a':1, 'b':2 })\n",
    "]\n",
    "\n",
    "dict(tpls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, no caso de as chaves de um dicionário serem strings, podemos criar dicionários passando chaves e valores como argumentos nomeados para a função `dict`. Porém, tenha em mente que neste caso números não podem ser usados como chaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'k1': 'Olá', 'k9': 42}"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict( k1=\"Olá\", k9=42 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compreensão de Dicionários (Dict comprehension)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como vimos para listas, o método de **compreensão de dicionários**, documentado [aqui](https://docs.python.org/3/tutorial/datastructures.html#dictionaries), permite a criação de dicionários usando uma expressão."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este método usa a mesma sintaxe base da compreensão de listas, com duas distinções: (*i*) o uso de chaves no lugar de colchetes; e (*ii*) expressões distintas para o registro da chave e valor em cada iteração, separadas por dois pontos (`:`):\n",
    "```python\n",
    "{ expressão_chave(item):expressão_valor(item) for item in lista if condição(item) }\n",
    "```\n",
    "\n",
    "sendo \n",
    "* `lista`: uma lista pré-existente, ou objeto a ser iterado;\n",
    "* `item`: a variável de iteração;\n",
    "* `expressão_chave`: uma expressão que pode usar o valor em `item`, a ser incluída como chave;\n",
    "* `expressão_valor`: uma expressão que pode usar o valor em `item`, a ser incluída como valor;\n",
    "* `condição` (opcional): o resultado da expressão só é incluído na lista final caso a avaliação da condição resulte em `True`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos criar, por exemplo, um dicionário cujas chaves são números pares de 1 a 20; e os valores são seus quadrados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: 4,\n",
       " 4: 16,\n",
       " 6: 36,\n",
       " 8: 64,\n",
       " 10: 100,\n",
       " 12: 144,\n",
       " 14: 196,\n",
       " 16: 256,\n",
       " 18: 324,\n",
       " 20: 400}"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ x:x**2 for x in range(1,21) if x%2==0}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De forma análoga, poderíamos criar um dicionário cujas chaves são os quadrados dos números pares de 1 a 20; e os valores são os próprios números"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4: 2,\n",
       " 16: 4,\n",
       " 36: 6,\n",
       " 64: 8,\n",
       " 100: 10,\n",
       " 144: 12,\n",
       " 196: 14,\n",
       " 256: 16,\n",
       " 324: 18,\n",
       " 400: 20}"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ x**2:x for x in range(1,21) if x%2==0}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Acessando elementos em um dicionário"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acessar elementos de um dicionário usando a notação de **indexação**. Ela é bem parecida com a notação que usamos para listas e tuplas, com a única diferença de que agora o índice não é mais posicional. Recuperamos um determinado valor usando como índice sua chave"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'k1': \"val1\", 'k2': \"val2\", 'k3': \"val3\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'val1'"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['k1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'val2'"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['k2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'val3'"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['k3']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também atualizar o valor associado a uma determinada chave usando a notação de indexação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['k1'] = \"val1.2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['k2'] = \"val2.2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'k1': 'val1.2', 'k2': 'val2.2', 'k3': 'val3'}"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou mesmo inserir chaves e valores novos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['k4'] = \"val4\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['k5'] = \"val5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'k1': 'val1.2', 'k2': 'val2.2', 'k3': 'val3', 'k4': 'val4', 'k5': 'val5'}"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas receberemos uma mensagem de erro se tentarmos resgatar um valor usando uma chave inexistente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'k9'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-144-17f959e6f626>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'k9'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'k9'"
     ]
    }
   ],
   "source": [
    "d['k9']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para evitar que este erro quebre nosso programa, podemos usar o método `get`, que retorna um valor pré-definido caso a chave não exista no dicionário. Por *default*, o valor pré-definido é nulo (`None`), mas podemos especificar qualquer outro valor, passando como o segundo argumento para a função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.get('k9')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Não encontrado!'"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.get('k9',\"Não encontrado!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combinando dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferentemente de listas, dicionários não podem ser **combinados** usando o operador `+`. Em vez disso, podemos **atualizar** um dicionário com o conteúdo de outro, usando o método `update`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = {'k1':\"val1\", 'k2':\"val2\"}\n",
    "d2 = {'k3':\"val3\"}\n",
    "d3 = {'k4':\"val4\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'k1': 'val1', 'k2': 'val2', 'k3': 'val3'}"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1.update(d2)\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'k1': 'val1', 'k2': 'val2', 'k3': 'val3', 'k4': 'val4'}"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1.update(d3)\n",
    "d1"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}