{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dcdb55e5",
   "metadata": {},
   "source": [
    "# Estruturas de dados: listas\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90880d8d",
   "metadata": {},
   "source": [
    "## Revisão\n",
    "\n",
    "Antes de começar seria bom fazer uma revisão e reforçar alguns conceitos.\n",
    "\n",
    "Na aula passada Vimos rcondicionais e repeticções\n",
    "\n",
    "### Condicionais\n",
    "\n",
    "Com expressões condicionais, podemos selecionar o que é executado. O mecanismo básico é a expressão `if`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "424c4a5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Executado porque a condição é verdadeira\n"
     ]
    }
   ],
   "source": [
    "condição = True\n",
    "if condição:\n",
    "    print(\"Executado porque a condição é verdadeira\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "643399cc",
   "metadata": {},
   "source": [
    "<!-- TEASER_END -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "06f07cbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "condição = False\n",
    "if condição:\n",
    "    print(\"Executado porque a condição é verdadeira\")\n",
    "    \n",
    "# Nada foi impresso porque a condição é falsa"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73b6e342",
   "metadata": {},
   "source": [
    "Existe uma outra forma da expressão `if`. Se a condição for verdadeira, funciona igual. Caso contrário executa a parte do `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f68c7efc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Executando porque a condição é FALSA\n"
     ]
    }
   ],
   "source": [
    "condição = False\n",
    "if condição:\n",
    "    print(\"Executando porque a condição é verdadeira\")\n",
    "else:\n",
    "    print(\"Executando porque a condição é FALSA\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a3d163a",
   "metadata": {},
   "source": [
    "Algumas vezes queremos escolher mais de uma condição. \n",
    "Para isso temos o `elif`. \n",
    "\n",
    "Com isso o `if` vai verificar cada condição sequencialmente. \n",
    "Quando alguma das condições for verdadeira (`True`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "568479c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cond4\n"
     ]
    }
   ],
   "source": [
    "cond1 = False\n",
    "cond2 = False\n",
    "cond3 = False\n",
    "cond4 = True\n",
    "\n",
    "if cond1:\n",
    "    print(\"cond1\")\n",
    "elif cond2:\n",
    "    print(\"cond2\")\n",
    "elif cond3:\n",
    "    print(\"cond3\")\n",
    "elif cond4:\n",
    "    print(\"cond4\")\n",
    "else: \n",
    "    print(\"Nada foi verdadeiro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee48a4dc",
   "metadata": {},
   "source": [
    "#### Detalhe importante:\n",
    "\n",
    "Até este momento associei `if` a expressões condicionais. Este é o jeito mais seguro e comum de usar. Na verdade, `if` (e `elif`) considera algo verdadeiro se não foi `0`, `False` ou estrutura de dados vazia (veremos estruturas de dados hoje). O resto é verdade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9393e14f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FALSE\n"
     ]
    }
   ],
   "source": [
    "if 0:\n",
    "    print(\"TRUE\")\n",
    "else:\n",
    "    print(\"FALSE\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcd48763",
   "metadata": {},
   "source": [
    "### Repetições\n",
    "\n",
    "Mostramos como se repete alguma operação com Python. O mecanismo mais básico é a expressão `while`:\n",
    "\n",
    "```python\n",
    "while condição:\n",
    "    # Executar este bloco\n",
    "    # enquanto condição for verdadeira\n",
    "```\n",
    "\n",
    "Enquanto a `condição` for verdadeira, o bloco vai ser executado. Por isso é importante que se faça algo para tornar a `condição` falsa de modo a interromper o laço."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d00f5d46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3aad050",
   "metadata": {},
   "source": [
    "Algo que não foi falado é que você pode interromper \n",
    "em qualquer lugar a execução do laço com a expressão `break`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6ce1f863",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while True:\n",
    "    if i > 5:\n",
    "        break\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb748aad",
   "metadata": {},
   "source": [
    "Em várias linguagens de programação existem mecanismos para se criar laços onde o teste está no final, de modo que o **corpo do laço seja executado pelo menos uma vez**. Em C, isso seria os laços `do - while`. Não existe nada parecido em Python. Mas isso não é necessário, basta usar o `break`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b3f5a3be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while True:\n",
    "    print(i)\n",
    "    i = i + 1\n",
    "    if i > 5: break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25cadde7",
   "metadata": {},
   "source": [
    "Muitas vezes você não quer sair do laço \n",
    "mas simplesmente ir para a próxima iteração. \n",
    "Para isso existe a expressão `continue`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "83ba2f57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "    i = i + 1\n",
    "    if i == 3:\n",
    "        continue\n",
    "    print(i)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40adc8b6",
   "metadata": {},
   "source": [
    "# Estrtuturas de dados\n",
    "\n",
    "Até este momento, vimos a criação de variáveis que armazenavam números (inteiros ou de ponto flutuante) ou strings. E se quisermos trabalhar com uma quantidade variável de números (ou strings)? Teríamos que criar mais de uma variável. Isso não apenas é chato mas bem limitante. Para isso existem as estruturas de dados que são elementos do Python que permitem armazenar e gerenciar mais de um objeto (números, strings, ou qualquer outra coisa).\n",
    "\n",
    "O strings são um caso especial pois são uma coleção de caracteres. Mas em geral os strings são tratados como um elemento único."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62c24de6",
   "metadata": {},
   "source": [
    "## Listas\n",
    "\n",
    "As listas são um tipo de variável que permitem armazenar vários valores acessados por um índice. A lista pode conter 0 ou mais elementos de qualquer tipo, inclusive outras listas (e outras estruturas de dados).\n",
    "\n",
    "Assim como os caracteres de uma string, as listas são indexadas por números inteiros começando em 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b62ee252",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Uma lista vazia\n",
    "L = []\n",
    "print(len(L))\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8dafed85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "Z = [15, 8, 9]\n",
    "print(Z[0])\n",
    "print(Z[1])\n",
    "print(Z[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2a0a8347",
   "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/tmp/ipykernel_3105/1148129213.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Erro se o índice não existir\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mZ\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# Erro se o índice não existir\n",
    "Z[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "90ec652d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 123, 9]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# É possível mudar o valor das variáveis\n",
    "Z[1] = 123\n",
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "42f0df90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Média:  7.0\n"
     ]
    }
   ],
   "source": [
    "# Programa para cálculo da média de 5 notas\n",
    "notas = [6, 7, 5, 8, 9]\n",
    "soma = 0\n",
    "i = 0\n",
    "while i < 5:\n",
    "    soma += notas[i]\n",
    "    i += 1\n",
    "print(f\"Média: {soma/i:4.1f}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "232aa9ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nota 0: 5\n",
      "Nota 1: 6\n",
      "Nota 2: 8\n",
      "Nota 3: 7\n",
      "Nota 4: 9\n",
      "Média:  7.0\n"
     ]
    }
   ],
   "source": [
    "# Versão do programa onde o professor pode entrar com as notas\n",
    "notas = [0,0,0,0,0]\n",
    "soma = 0\n",
    "i = 0\n",
    "while i < 5:\n",
    "    notas[i] = float(input(f\"Nota {i}: \"))\n",
    "    soma += notas[i]\n",
    "    i += 1\n",
    "print(f\"Média: {soma/i:4.1f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75c45473",
   "metadata": {},
   "source": [
    "### Exercício 1\n",
    "Modifique os programas acima para ler 7 notas no lugar de 5."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86e31c03",
   "metadata": {},
   "source": [
    "## Cópia e fatiamento de listas "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0075e6b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1,2,3,4,5]\n",
    "V = L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e4699ec4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "158506c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "89dbbcc1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[999, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V[0] = 999\n",
    "V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ba3c8042",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[999, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "341b9067",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1,2,3,4,5]\n",
    "V = L[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9a4df9d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "V[0] = 999"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9625cb20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[999, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c7c6ece0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7998ebc5",
   "metadata": {},
   "source": [
    "### Fatiamento de listas\n",
    "Lembra do fatiamento de strings? Listas funcionam de maneira bem parecida"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "77ed306b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABCDEF'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"ABCDEF\"\n",
    "s[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "82786abd",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f06471d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3e73fb43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "0b24c02f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "efaa7155",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5af4a963",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f727f40",
   "metadata": {},
   "source": [
    "### Tamanho de listas\n",
    "A função `len` retorna o número de elementos de uma lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b2ea5004",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c02e9ece",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "fb08945a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "abb12abd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c81a1a83",
   "metadata": {},
   "source": [
    "Lembra do programa para tirar a média? Com `len` dá para melhorar!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "b73ed635",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Média:  7.0\n"
     ]
    }
   ],
   "source": [
    "# Programa para cálculo da média de 5 notas\n",
    "notas = [6, 7, 5, 8, 9]\n",
    "\n",
    "soma = 0\n",
    "i = 0\n",
    "while i < len(notas):\n",
    "    soma += notas[i]\n",
    "    i += 1\n",
    "print(f\"Média: {soma/i:4.1f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99039bce",
   "metadata": {},
   "source": [
    "### Adicionando elementos a uma lista\n",
    "\n",
    "As listas podem crescer de acordo com a conveniência. Para adicionar um elemento a uma lista, basta usar o *método* `append`.\n",
    "\n",
    "Um método parece com uma função (como `len`) mas está associado ao objeto. Em python, as variáveis armazenam objetos que podem ser números, strings, listas, e um monte de outras coisas. \n",
    "\n",
    "Funções recebem (entre parênteses) objetos e retornam um outro objeto. Mas métodos estão associados a estes objetos, são parte intrínseca dos objetos. No final do curso vamos ver em detalhes como isso funciona. Mas por enquanto, vamos aprender a utilizá-los.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5e7fa92",
   "metadata": {},
   "source": [
    "#### Dica de como ver os métodos disponíveis\n",
    "Se você tiver alguma variável, digite seu nome, digite ponto (sem espaço!) e pressione a tecla TAB. Vai aparecer uma lista com os métodos disponíveis para a variável. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b24ebbed",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "8a41b266",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "12b03766",
   "metadata": {},
   "outputs": [],
   "source": [
    "L.append(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "475d56f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "a499faf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "L.append(\"b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "7ed19a25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "ad296b6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "L.append(\"c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "04c674cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c81d9136",
   "metadata": {},
   "outputs": [],
   "source": [
    "L.append([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "7c7d3369",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', [1, 2, 3]]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "e1484eec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número (0 sai): 5\n",
      "Digite um número (0 sai): 3\n",
      "Digite um número (0 sai): 9\n",
      "Digite um número (0 sai): 6\n",
      "Digite um número (0 sai): 11\n",
      "Digite um número (0 sai): 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[5, 3, 9, 6, 11]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Programa para adicionar números a uma lista\n",
    "L = []\n",
    "while True:\n",
    "    n = int(input(\"Digite um número (0 sai): \"))\n",
    "    if n == 0:\n",
    "        break\n",
    "    L.append(n)\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3def5e1",
   "metadata": {},
   "source": [
    "#### Vocês se lembram da concatenação de strings?\n",
    "A mesma coisa é possível com listas. Apenas com listas!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "9a8b71e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] + [4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "d2484218",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] + [4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "030bf7a2",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate list (not \"int\") to list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_3105/2703596034.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list"
     ]
    }
   ],
   "source": [
    "[1,2,3] + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6f794dc",
   "metadata": {},
   "source": [
    "O método `append` adiciona elementos novos à lista. \n",
    "Já o método `extend` funciona como a concatenação acima."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "9a4ef860",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "d213d1f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "L.append(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "6354b56c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "d360a574",
   "metadata": {},
   "outputs": [],
   "source": [
    "L.append([5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "7e978bb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, [5, 6]]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "1df52d48",
   "metadata": {},
   "outputs": [],
   "source": [
    "L.extend([7,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "34e47ce2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, [5, 6], 7, 8]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7887319",
   "metadata": {},
   "source": [
    "### Exercício 2\n",
    "Reescreva o programa para calcular médias de modo que o professor primeiro entra com o número de notas e em seguida o programa lê este número de notas e calcula a média."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34368277",
   "metadata": {},
   "source": [
    "### Exercício 3\n",
    "Faça um programa que percorra duas listas inteiras e gere uma terceira sem elementos repetidos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f01bbb3",
   "metadata": {},
   "source": [
    "### Remoção de elementos da lista\n",
    "\n",
    "Algumas vezes você quer remover elementos da lista. Isso é feito com a instrução `del`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "fd227ab1",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "21166fa1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del L[1]\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "e5b60859",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = list(range(101))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "0b5a8818",
   "metadata": {},
   "outputs": [],
   "source": [
    "del L[10:90]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "163e88aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "f4aaebf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = list(range(11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "ce8e48c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.pop(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a432df77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0af24c1b",
   "metadata": {},
   "source": [
    "### Filas\n",
    "\n",
    "Uma lista pode ser utilizada como uma fila. Numa fila as pessoas \n",
    "entram no final e saem no começo. Na literatura a fila é conhecida como FIFO  (*First In First Out*, primeiro que entra primeiro que sai). É uma estrutura de dados muito útil em diversas situações.\n",
    "\n",
    "\n",
    "Como exemplo vamos simular uma fila de banco:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "c508e5b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Existem 10 clientes na fila\n",
      "Fila atual: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Digite F para adicionar um cliente ao fim da fila, \n",
      "ou A para realizar o atendimento. S para sair.\n",
      "Operação (F, A ou S): A\n",
      "Cliente 1 atendido\n",
      "\n",
      "Existem 9 clientes na fila\n",
      "Fila atual: [2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Digite F para adicionar um cliente ao fim da fila, \n",
      "ou A para realizar o atendimento. S para sair.\n",
      "Operação (F, A ou S): A\n",
      "Cliente 2 atendido\n",
      "\n",
      "Existem 8 clientes na fila\n",
      "Fila atual: [3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Digite F para adicionar um cliente ao fim da fila, \n",
      "ou A para realizar o atendimento. S para sair.\n",
      "Operação (F, A ou S): F\n",
      "\n",
      "Existem 9 clientes na fila\n",
      "Fila atual: [3, 4, 5, 6, 7, 8, 9, 10, 11]\n",
      "Digite F para adicionar um cliente ao fim da fila, \n",
      "ou A para realizar o atendimento. S para sair.\n",
      "Operação (F, A ou S): S\n"
     ]
    }
   ],
   "source": [
    "# Simulação de fila de banco:\n",
    "último = 10\n",
    "fila = list(range(1, último + 1))\n",
    "while True:\n",
    "    print(f\"\\nExistem {len(fila)} clientes na fila\")\n",
    "    print(f\"Fila atual: {fila}\")\n",
    "    print(\"Digite F para adicionar um cliente ao fim da fila, \")\n",
    "    print(\"ou A para realizar o atendimento. S para sair.\")\n",
    "    operação = input(\"Operação (F, A ou S): \")\n",
    "    if operação == \"A\":\n",
    "        if len(fila) > 0:\n",
    "            atendido = fila.pop(0)\n",
    "            print(f\"Cliente {atendido} atendido\")\n",
    "        else:\n",
    "            print(\"Fila vazia! Nenhum cliente para atender.\")\n",
    "    elif operação == \"F\":\n",
    "        último += 1 # Incrementa o ticket\n",
    "        fila.append(último)\n",
    "    elif operação == 'S':\n",
    "        break\n",
    "    else:\n",
    "        print(\"Operação inválida. Digite apenas A, F ou S!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f10cbcd4",
   "metadata": {},
   "source": [
    "### Exercício 4\n",
    "O que acontece quando não verificamos se a lista está vazia antes de chamar o método `pop`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07113536",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b5af9782",
   "metadata": {},
   "source": [
    "### Exercício 5\n",
    "Altere o programa da fila de modo que se possa trabalhar com vários comandos digitados de uma só vez. No programa acima, apenas uma operação pode ser digitada por vez. Faça com que o programa aceite strings com vários comandos\n",
    "\n",
    "Exemplo: FFFAAAS significa três chegadas de novos clientes, três atendimentos e saída do programa.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ac23982",
   "metadata": {},
   "source": [
    "### Listas como pilhas\n",
    "\n",
    "Uma outra estrutura de dados muito importante é a pilha. Em inglês isso se chama *stack*. Neste tipo de estrutura, você insere elementos no final e eles saem pelo final. Na literatura, listas são conhecidas como LIFO - *Last In First Out* (último a entrar é o primeiro a sair).\n",
    "\n",
    "Nesse caso, para se adicionar um elemento à pilha, usa-se o método `append`. Para se retirar um elemento da pilha, o método `pop` sem nenhum argumento (our argumento -1 que indica o último elemento).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "20182c92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Existem 5 pratos na pilha\n",
      "Pilha atual: [1, 2, 3, 4, 5]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 5 lavado\n",
      "\n",
      "Existem 4 pratos na pilha\n",
      "Pilha atual: [1, 2, 3, 4]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 4 lavado\n",
      "\n",
      "Existem 3 pratos na pilha\n",
      "Pilha atual: [1, 2, 3]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): E\n",
      "\n",
      "Existem 4 pratos na pilha\n",
      "Pilha atual: [1, 2, 3, 6]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): E\n",
      "\n",
      "Existem 5 pratos na pilha\n",
      "Pilha atual: [1, 2, 3, 6, 7]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): E\n",
      "\n",
      "Existem 6 pratos na pilha\n",
      "Pilha atual: [1, 2, 3, 6, 7, 8]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 8 lavado\n",
      "\n",
      "Existem 5 pratos na pilha\n",
      "Pilha atual: [1, 2, 3, 6, 7]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 7 lavado\n",
      "\n",
      "Existem 4 pratos na pilha\n",
      "Pilha atual: [1, 2, 3, 6]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 6 lavado\n",
      "\n",
      "Existem 3 pratos na pilha\n",
      "Pilha atual: [1, 2, 3]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 3 lavado\n",
      "\n",
      "Existem 2 pratos na pilha\n",
      "Pilha atual: [1, 2]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 2 lavado\n",
      "\n",
      "Existem 1 pratos na pilha\n",
      "Pilha atual: [1]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 1 lavado\n",
      "\n",
      "Existem 0 pratos na pilha\n",
      "Pilha atual: []\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Pilha vazia, nada para lavar!\n",
      "\n",
      "Existem 0 pratos na pilha\n",
      "Pilha atual: []\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Pilha vazia, nada para lavar!\n",
      "\n",
      "Existem 0 pratos na pilha\n",
      "Pilha atual: []\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): E\n",
      "\n",
      "Existem 1 pratos na pilha\n",
      "Pilha atual: [9]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 9 lavado\n",
      "\n",
      "Existem 0 pratos na pilha\n",
      "Pilha atual: []\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): E\n",
      "\n",
      "Existem 1 pratos na pilha\n",
      "Pilha atual: [10]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): E\n",
      "\n",
      "Existem 2 pratos na pilha\n",
      "Pilha atual: [10, 11]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 11 lavado\n",
      "\n",
      "Existem 1 pratos na pilha\n",
      "Pilha atual: [10]\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Prato 10 lavado\n",
      "\n",
      "Existem 0 pratos na pilha\n",
      "Pilha atual: []\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): D\n",
      "Pilha vazia, nada para lavar!\n",
      "\n",
      "Existem 0 pratos na pilha\n",
      "Pilha atual: []\n",
      "Digite E para empilhar um novo prato,\n",
      "ou D para desempilhar e lavar. S para sair.\n",
      "Operação (E, D ou S): S\n"
     ]
    }
   ],
   "source": [
    "# Programa para gerenciar a lavagem de pratos\n",
    "prato = 5 \n",
    "pilha = list(range(1,prato+1))\n",
    "while True:\n",
    "    print(f\"\\nExistem {len(pilha)} pratos na pilha\")\n",
    "    print(f\"Pilha atual: {pilha}\")\n",
    "    print(\"Digite E para empilhar um novo prato,\")\n",
    "    print(\"ou D para desempilhar e lavar. S para sair.\")\n",
    "    operação = input(\"Operação (E, D ou S): \")\n",
    "    if operação == 'D':\n",
    "        if len(pilha) > 0:\n",
    "            lavado = pilha.pop(-1)\n",
    "            print(f\"Prato {lavado} lavado\")\n",
    "        else:\n",
    "            print(\"Pilha vazia, nada para lavar!\")\n",
    "    elif operação == 'E':\n",
    "        prato += 1\n",
    "        pilha.append(prato)\n",
    "    elif operação == 'S':\n",
    "        break\n",
    "    else:\n",
    "        print(\"Operação inválida. Digite apenas E, D ou S!\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7610085",
   "metadata": {},
   "source": [
    "### Exercício 6\n",
    "Faça um programa que leia uma expressão com parênteses. Usando pilhas, verifique se os parênteses foram abertos e fechados na ordem correta. Exemplo:\n",
    "\n",
    " * (()) OK\n",
    " * ()()(()()) OK\n",
    " * ()) Erro\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6e0e977",
   "metadata": {},
   "source": [
    "### Pesquisando\n",
    "\n",
    "Uma outra operação importante é pésquisar uma lista e verificar se um elemento é parte dela."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "01a0dbfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite o valor a procurar: 39\n",
      "39 foi encontrado na posição 3.\n"
     ]
    }
   ],
   "source": [
    "L = [15, 7, 27, 39]\n",
    "p = int(input(\"Digite o valor a procurar: \"))\n",
    "achou = False\n",
    "i = 0\n",
    "while i < len(L):\n",
    "    if L[i] == p:\n",
    "        achou = True\n",
    "        break\n",
    "    i += 1\n",
    "if achou:\n",
    "    print(f\"{p} foi encontrado na posição {i}.\")\n",
    "else:\n",
    "    print(f\"{p} não foi encontrado na lista.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b78f6e60",
   "metadata": {},
   "source": [
    "### Exercício 7\n",
    "Modifique o programa de modo que  realize a mesma tarefa sem usar a variável `achou`. Dica: observe a condição de saída do `while`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "008485d2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0c42320e",
   "metadata": {},
   "source": [
    "### Exercício 8\n",
    "Modifique o exemplo para pesquisar dois valores. Em vez de apenas `p`, leia outro valor `v` que também será procurado. Na impressão, indique qual dos dois valores foi encontrado primeiro."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3afb3cbf",
   "metadata": {},
   "source": [
    "## Usando `for`\n",
    "\n",
    "Para realizar repetições temos usado a instrução `while`. Repare que muitas vezes a gente quer percorrer uma lista ou um range de números. Isso é tão comum que o python fornece uma instrução de repetição para estes casos: `for.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "b9b12fb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "9\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "L = [8,9,15]\n",
    "for e in L:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "227e492e",
   "metadata": {},
   "source": [
    "No exemplo anterior, em cada iteração do laço `for`, o valor `e` assume um valor da lista `L` de maneira sequencial.\n",
    "\n",
    "O código acima é equivalente ao código a seguir que usa `while`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "7a4af703",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "9\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "L = [8,9,15]\n",
    "i = 0\n",
    "while i < len(L):\n",
    "    e = L[i]\n",
    "    print(e)\n",
    "    i = i + 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab6b81a5",
   "metadata": {},
   "source": [
    "As instruções `break` e `continue` funcionam da mesma maneira no laço `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "2fb79703",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número a pesquisar: 10\n",
      "Elemento encontrado!\n"
     ]
    }
   ],
   "source": [
    "# Programa de busca\n",
    "L = [7,9,10,12]\n",
    "p = int(input(\"Digite um número a pesquisar: \"))\n",
    "for e in L:\n",
    "    if e == p:\n",
    "        print(\"Elemento encontrado!\")\n",
    "        break\n",
    "else:\n",
    "    print(\"Elemento não encontrado\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "b80316c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Terminou\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 3:\n",
    "    print(i)\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"Terminou\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "53fa94c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor máximo de [8, 23, 2, 67, 4] é 67\n"
     ]
    }
   ],
   "source": [
    "# Programa para achar o máximo de uma lista:\n",
    "x = [8, 23, 2, 67, 4]\n",
    "xmax = x[0]\n",
    "for e in x:\n",
    "    if e > xmax:\n",
    "        xmax = e\n",
    "print(f\"Valor máximo de {x} é {xmax}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ba90946",
   "metadata": {},
   "source": [
    "### Exercício 9\n",
    "Tente converter este programa (exemplo acima)\n",
    "\n",
    "```python\n",
    "# Programa para adicionar números a uma lista\n",
    "L = []\n",
    "while True:\n",
    "    n = int(input(\"Digite um número (0 sai): \"))\n",
    "    if n == 0:\n",
    "        break\n",
    "    L.append(n)\n",
    "```\n",
    "usando `for`.\n",
    "\n",
    "Explique se `for` pode ser sempre usado no lugar de `while` e porquê."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0d4b0aa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "488f831d",
   "metadata": {},
   "source": [
    "### Range\n",
    "\n",
    "Usamos anteriormente a função `range`. Esta função cria uma sequência de números e parece ser uma lista mas não é. Sendo uma sequência conhecida, porque gastar memória armazenando todos os elementos?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "011aff32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 5)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "c88fb76e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A função `list` converte para lista:\n",
    "list(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "2e285fd0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dá para especificar o valor inicial\n",
    "list(range(3,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "a6695b7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# E também dá para escpeficar o intervalo (passo entre valores:)\n",
    "list(range(3,33,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "0530bf8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Mas mais importante, dá para usar nos laços `for`!\n",
    "\n",
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "265be9a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 6 9 12 15 18 21 24 27 30 \n"
     ]
    }
   ],
   "source": [
    "for t in range(3,33,3):\n",
    "    print(t, end=\" \") # Repare no `end`\n",
    "print()\n",
    "#print(\"ABCDEF\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6561501",
   "metadata": {},
   "source": [
    "## `enumerate`\n",
    "\n",
    "Muitas vezes (quase sempre?) além do valor do elemento na lista, queremos também o índice. Para isso, usamos `enumerate`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "9c55895c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L[0] = 5\n",
      "L[1] = 9\n",
      "L[2] = 13\n"
     ]
    }
   ],
   "source": [
    "L = [5,9,13]\n",
    "i = 0\n",
    "for e in L:\n",
    "    print(f\"L[{i}] = {e}\")\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "276d4c27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L[0] = 5\n",
      "L[1] = 9\n",
      "L[2] = 13\n"
     ]
    }
   ],
   "source": [
    "L = [5,9,13]\n",
    "for i, e in enumerate(L):\n",
    "    print(f\"L[{i}] = {e}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2215c75",
   "metadata": {},
   "source": [
    "### Exercício 10\n",
    "Escreva um programa que acha o menor elemento de uma lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "075b6d4b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "26b1d749",
   "metadata": {},
   "source": [
    "### Exercício 11\n",
    "Modifique o programa para achar o máximo de modo que encontre o máximo mas também encontre o índice onde este máximo ocorre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b4aafd2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fb96ba10",
   "metadata": {},
   "source": [
    "### Exercício 12\n",
    "Escreva um programa que encontra o máximo e o mínimo de uma lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e88f7bf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d0d43044",
   "metadata": {},
   "source": [
    "## Ordenação de listas\n",
    "\n",
    "Colocar a lista em ordem crescente ou descrescente é extremamente importante. Aqui vamos apresentar o método de ordenação de bolhas (*bubble sort* na literatura)\n",
    "\n",
    "Qual a idéia do algorítmo? Vamos tomar como exemplo a lista\n",
    "```python\n",
    "L = [9, 2, 4, 3, 8, 6]\n",
    "```\n",
    "Começamos a percorrer a lista ordenando a lista par a par\n",
    "\n",
    " 1. ```python\n",
    "    [2, 9, 3, 4, 8, 6]\n",
    "    ```\n",
    " 2. ```python\n",
    "    [2, 3, 9, 4, 8, 6]\n",
    "    ```\n",
    " 3. ```python\n",
    "    [2, 3, 4, 9, 8, 6]\n",
    "    ```\n",
    " 4. ```python\n",
    "    [2, 3, 4, 8, 9, 6]\n",
    "    ```\n",
    " 5. ```python\n",
    "    [2, 3, 4, 8, 6, 9]\n",
    "    ```\n",
    "Agora começamos novamente mas não precisamos ir até o final: o maior elemento já está lá!\n",
    "\n",
    " 1. ```python\n",
    "    [2, 3, 4, 8, 6, 9] # Não fez nada 2 < 3\n",
    "    ```\n",
    " 2. ```python\n",
    "    [2, 3, 4, 8, 6, 9] # Não fez nada 3 < 4\n",
    "    ```\n",
    " 3. ```python\n",
    "    [2, 3, 4, 8, 6, 9] # Não fez nada 4 < 8\n",
    "    ```\n",
    " 4. ```python\n",
    "    [2, 3, 4, 6, 8, 9] # Não fez nada 4 < 8\n",
    "    ```\n",
    "Começamos de novo mas agora só até o penúltimo. Mas agora a lista está ordenada então podemos parar.\n",
    "\n",
    " \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "88f85632",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 6, 8, 9]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [9, 2, 4, 3, 8, 6]\n",
    "N = len(L)\n",
    "for i in range(N):\n",
    "    trocou = False\n",
    "    for k in range(N-i-1):\n",
    "        if L[k] > L[k+1]: # Inverter a posição\n",
    "            trocou = True\n",
    "            tmp = L[k]\n",
    "            L[k] = L[k+1]\n",
    "            L[k+1] = tmp\n",
    "    if not trocou:\n",
    "        break\n",
    "\n",
    "L\n",
    "        \n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "632abb8e",
   "metadata": {},
   "source": [
    "### Exercício 13\n",
    "Modifique o programa anterior para que ordene a lista em modo decrescente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "a2b77a76",
   "metadata": {},
   "outputs": [],
   "source": [
    "?L.sort"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f09f238d",
   "metadata": {},
   "source": [
    "### Exercício 14\n",
    "O que acontece se você tentar usar o programa acima com uma lista de strings? Tente e brinque um pouquinho.\n",
    "\n",
    "Por outro lado, o que acontece se misturarmos números e strings?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a658700d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ceb122e9",
   "metadata": {},
   "source": [
    "### Exercício 15\n",
    "Um aspecto importante é saber p quão eficiente é este algorítimo. Para tanto, precisamos saber quanto tempo leva para ordenar a lista. \n",
    "\n",
    "Mas isso vai depender do tamanho da lista, do tipo de dados dentro da lista e do computador que está executando o programa. No entanto, para efeito comparativo, podemos estimar o número de operações. Neste caso, podemos falar em quantas comparações foram realizadas (A linha `L[k] > L[k+1]`). Também é interessante saber quantas inversões foram realizadas. Estime esse custo para os dois seguintes casos:\n",
    "\n",
    " 1. Uma lista ordenada de maneira crescente de comprimento N\n",
    " 2. Uma lista ordenada de maneira decrescente de comprimento N\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77eb293e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "87be28b2",
   "metadata": {},
   "source": [
    "## Métodos das listas\n",
    "\n",
    "As listas já possuem métodos úteis. Você pode procurar isso na documentação mas também pode ver isso de maneira iterativa no terminal ou no notebook Jupyter. Basta criar uma variável que armazena a lista, digitar esta variável, ponto e pressionar TAB:\n",
    "\n",
    "```python\n",
    "x = [2,5,3,8,5,3,5,7,9,]\n",
    "x.<TAB>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "e8ab62e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [2,5,3,8,5,3,5,7,9,]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "9b343221",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "1e3eb43a",
   "metadata": {},
   "outputs": [],
   "source": [
    "?x.\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fca5473",
   "metadata": {},
   "source": [
    "### Alguns dos métodos:\n",
    "Se a lista está armazenada em `x`, temos os seguintes métodos:\n",
    " * `x.append`: adiciona elementos ao final da lista\n",
    " * `x.clear`: apaga todos os elementos da lista\n",
    " * `x.copy`: copia a lista e os elementos\n",
    " * `x.count`: conta o número de ocorrências de um elemento\n",
    " * `x.extend`: extende a lista com os elementos de outra lista\n",
    " * `x.index`: encontra índice de um elemento\n",
    " * `x.insert`: adiciona um elemento na posição antes do índice\n",
    " * `x.pop`: remove e retorna o elemento na posição do índice\n",
    " * `x.remove`: remove a primeira ocorrência de um valor\n",
    " * `x.reverse`: reverte a ordem dos elementos\n",
    " * `x.sort`: reordena os elementos da lista\n",
    " \n",
    " Estes métodos são úteis e em geral é recomendado que sejam utilizados: provavelmente são mais rápidos, flexíveis e seguros do que qualquer coisa que você faça."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b98103d7",
   "metadata": {},
   "source": [
    "### Exercício 16\n",
    "Explore os métodos das listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8d479d2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e6e702e8",
   "metadata": {},
   "source": [
    "### Exercício 17\n",
    "Não são apenas as listas que têm métodos. Números e strings também têm métodos. Explore-os da mesma maneira que você fez com os métodos das listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15e16912",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7d0bb683",
   "metadata": {},
   "source": [
    "## Antecipando o futuro: funções\n",
    "\n",
    "O algorítimo de ordenação pode ser encapsulado numa função. Assim o programa pode ser reutilizado quando for necessário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "24b661ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bubble_sort(L):\n",
    "    N = len(L)\n",
    "    for i in range(N):\n",
    "        trocou = False\n",
    "        for k in range(N-i-1):\n",
    "            if L[k] > L[k+1]: # Inverter a posição\n",
    "                trocou = True\n",
    "                tmp = L[k]\n",
    "                L[k] = L[k+1]\n",
    "                L[k+1] = tmp\n",
    "        if not trocou:\n",
    "            break\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "5d71959d",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [23,4,5,2,3,6,2345,6,32,345,4]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "93958aad",
   "metadata": {},
   "outputs": [],
   "source": [
    "bubble_sort(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "d51c2d69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 4, 5, 6, 6, 23, 32, 345, 2345]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}