prog1/implementacoes/tutoriais/estruturasDeRepeticao.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "colab": {
      "name": "estruturasDeRepeticao.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "baXe7gU2OooL",
        "colab_type": "text"
      },
      "source": [
        "# Estruturas de Repetição"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bxiDQ8_QOooT",
        "colab_type": "text"
      },
      "source": [
        "Estruturas de repetição, também chamadas de *Laços de Repetição* ou de *iteração*, são blocos de códigos que se repetem de acordo com uma condição dada. Apesar de ser uma estrutura que costuma assustar quem está aprendendo a programar, elas são importantíssimas para a manutenção da legibilidade, simplicidade e compacticidade do código."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "79H__n0VOooX",
        "colab_type": "text"
      },
      "source": [
        "## Introdução"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SJL5htMxOoob",
        "colab_type": "text"
      },
      "source": [
        "Até o momento, enquanto estava vendo estruturas condicionais, você aprendeu a ***desviar*** o fluxo normal da execução do seu programa a partir de uma condição baseada em operadores lógicos. Essas mesmas operações serão utilizadas, mas desta vez para para realizar *loops*, ou seja, fazer com que um bloco do seu código se repita determinada ou indeterminadamente."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZUh6RZRAOoof",
        "colab_type": "text"
      },
      "source": [
        "*Caso sinta a necessidade de relembrar os operadores de comparação, estará disponibilizado abaixo novamente*:\n",
        "\n",
        "| Operador | Significado  | Ex. que retorna verdadeiro  | Ex. que retorna falso  \n",
        "| :------: | :------:| :-----:|:-----:|\n",
        "| **==**| Verifica a igualdade entre dois valores | 2 **==** 2 | 2 **==** 3\n",
        "| **!=**    | Verifica a desigualdade entre dois valores |  2 **!=** 3 | 2 **!=** 2\n",
        "| **>**      | Verifica se o primeiro valor é maior que o segundo |  3 **>** 2 | 2 **>** 3 \n",
        "| **<**      | Verifica se o primeiro valor é menor que o segundo |  2 **<** 3 | 3 **<** 2 \n",
        "| **>=**      | Verifica se o primeiro valor é maior ou igual que o segundo |  2 **>=** 2 | 2 **>=** 3\n",
        "| **<=**      | Verifica se o primeiro valor é menor ou igual que o segundo |  2 **<=** 2 | 3 **<=** 2\n",
        "| **<=**      | Verifica se o primeiro valor é menor ou igual que o segundo |  2 **<=** 2 | 3 **<=** 2\n",
        "| **in**      | Verifica se o primeiro valor está dentro do segundo |  \"a\" **in** \"banana\"| \"o\" **in** \"banana\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rPjm0_DaOooj",
        "colab_type": "text"
      },
      "source": [
        "## While"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_xm2PVwDOoom",
        "colab_type": "text"
      },
      "source": [
        "A primeira estrutura de repetição que vamos estudar é o **while**. Ele possui uma sintaxe parecida com a do **if**, mas que, ao invés de desviar o fluxo de seu código, o fará se repetir.\n",
        "\n",
        "```python\n",
        "while(<condicao>):\n",
        "    <enquanto_a_condicao_for_verdadeira_ele_executa_isso>\n",
        "```\n",
        "\n",
        "O while pode ser entendido como \"Enquanto a condição for verdadeira, execute isso...\". Enquanto a condição que ele recebe retornar o valor **True**, executará seu trecho de código, quando retornar **False**, irá passar pra próxima etapa do código. **Exemplo:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qxQJcgeYOoor",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e35bc949-f29e-49a4-9262-0f12b57b89c5"
      },
      "source": [
        "num = 0\n",
        "\n",
        "while (num < 5):\n",
        "    # enquanto a variável \"num\" for menor que 5, o código se repetirá.\n",
        "    num = num + 1\n",
        "\n",
        "print (\"O valor de num ao final da execução do while é: \" + str(num))"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O valor de num ao final da execução do while é: 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8qwt076eOoo3",
        "colab_type": "text"
      },
      "source": [
        "No exemplo acima, o loop while testa se o valor da variável *num* é menor que 5. Enquanto isso for verdade (o valor inicial é 0), serão executados os procedimentos identados abaixo dos dois pontos (**:**). Neste caso, fazemos uma reatribuição: chamamos de *num* o valor anterior atribuído a ele mesmo somado a 1. Vejamos outro exemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BFzXu_c7Ooo6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "outputId": "88d74aa8-4841-41fd-e0cf-c190ae4ebd64"
      },
      "source": [
        "valorEmDolar = 1\n",
        "valorEmReal = 3.74\n",
        "\n",
        "while (valorEmDolar <= 5):\n",
        "    # enquanto a variável \"valorEmDolar\" for menor ou igual a 5, o código se repetirá.\n",
        "    print (\"%i dólares valem %.2f reais!\" % (valorEmDolar, valorEmDolar * valorEmReal))\n",
        "    valorEmDolar += 1"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 dólares valem 3.74 reais!\n",
            "2 dólares valem 7.48 reais!\n",
            "3 dólares valem 11.22 reais!\n",
            "4 dólares valem 14.96 reais!\n",
            "5 dólares valem 18.70 reais!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C3AGmxoROopE",
        "colab_type": "text"
      },
      "source": [
        "O exemplo acima é bem parecido com o anterior, porém agora foi feita uma operação tomando como base o valor dentro do bloco de repetição e com string formatada. No caso, foi feito um cálculo tendo a referência a cotação atual do dólar em reais e, para cada valor da iteração, foi impresso o valor de ***x*** dólares em reais, com ***x*** variando entre 1 e 5.\n",
        "\n",
        "**CUIDADO!** Se não for incluída a última linha que \"incrementa\" o valor de \"valorEmDolar\", o loop testará sempre se `1 < 5`, o que sempre será verdadeiro. Isto acarretará em um problema bastante comum quando se está aprendendo a programar: *loops infinitos*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ojr4UtbOopI",
        "colab_type": "text"
      },
      "source": [
        "## Break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jDdgVLsaOopK",
        "colab_type": "text"
      },
      "source": [
        "O comando *break* serve para abortar um bloco de repetição por completo. Isso permite que você possa fazer loops *while* sem necessariamente definir uma condição, colocando apenas `True` em seu lugar, e abortando a operação quando quiser. Por exemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8g_xx9k5OopO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "96b275c7-3bbd-49d4-8f4d-09c8883c567e"
      },
      "source": [
        "num = 0\n",
        "\n",
        "while True:\n",
        "    if (num == 5):\n",
        "        # caso a variável \"num\" seja igual a 5, o laço irá ser quebrado.\n",
        "        break\n",
        "        \n",
        "    num = num + 1\n",
        "\n",
        "print (\"O valor de num ao final da execução do while é: \" + str(num))"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O valor de num ao final da execução do while é: 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HQYCUm43OopV",
        "colab_type": "text"
      },
      "source": [
        "O exemplo acima produzirá o mesmo resultado do primeiro exemplo deste tutorial.\n",
        "\n",
        "*Note que o break quebra apenas um laço while. Ou seja, se dois whiles estiverem aninhados e você utilizar o break no mais interno, apenas este será quebrado, enquanto o externo continuará executando seu fluxo normalmente.*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y2UFIsUEOopX",
        "colab_type": "text"
      },
      "source": [
        "## Continue"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KxuNTLL_OopZ",
        "colab_type": "text"
      },
      "source": [
        "O comando *continue* também é utilizado para interromper o ciclo de repetição, porém é de extrema importância saber diferenciá-lo do *break*: enquanto o *break* interrompe não só apenas o ciclo atual da execução, mas sim, todo o laço, o *continue* interrompe apenas o ciclo atual, ou seja, se a condição pré-definida no laço continuar sendo verdadeira, as próximas iterações irão acontecer.\n",
        "\n",
        "**Exemplo**: Imagine que você queira imprimir todos os números ímpares no intervalo de 1 a 10 dentro de um loop while. Você pode usar o *continue* para ignorar os números pares dentro do laço."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dv1ZD4jMOopd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "outputId": "cf867722-5251-4acc-8787-26a951acc0b6"
      },
      "source": [
        "num = 0\n",
        "\n",
        "while (num < 10):\n",
        "    num = num + 1\n",
        "    if ((num % 2 == 0)): # checa se o número é par através do resto da divisão por 2\n",
        "        continue\n",
        "    \n",
        "    print(num)"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "7\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "isVm6Ez8Oopl",
        "colab_type": "text"
      },
      "source": [
        "Note que não foi necessário a instrução *else* para o *if*, pois o *continue*, assim como o *break*, ignora todo o restante do laço."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vRPTXh8UOopm",
        "colab_type": "text"
      },
      "source": [
        "## For"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HCokLnNHOopq",
        "colab_type": "text"
      },
      "source": [
        "A segunda estrutura de repetição que será abordada é o **for**. Em Python, esta estrutura é uma das ferramentas mais poderosas e características da linguagem. Ele nos permite percorrer os itens de uma coleção (por enquanto, vamos tratar apenas de intervalos numéricos) e, para cada um deles, executar o bloco de código declarado no loop. Observe a sintaxe:\n",
        "\n",
        "```python\n",
        "for <var> in <intervalo>:\n",
        "    <bloco_de_execucao>\n",
        "```\n",
        "\n",
        "No exemplo abaixo, vamos definir um intervalo de 0 a 5 utilizando a funcão `range` de Python e utilizar o for para iterar sobre este intervalo e imprimir o valor atual. Cada valor dessa sequência gerada será atribuída à variável *x*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dYwhXGgWOopt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        },
        "outputId": "e977a3ea-bfff-4959-f9e8-abb1b4e61e3f"
      },
      "source": [
        "for x in range(6):\n",
        "    print(x)"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fNXXhCYBOop1",
        "colab_type": "text"
      },
      "source": [
        "*Note que dentro do **range** foi utilizado o número 6, e não 5. Isso se dá porque essa função não inclui o último valor dado, já que inicia sua do 0.*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WONvtvmHOop3",
        "colab_type": "text"
      },
      "source": [
        "**Dica**: Também é possível utilizar *break* e *continue* em um laço *for*, porém não é recomendado, pois o *for* é, teoricamente, feito para rodar um número determinado de vezes sem interrupções, o que é a principal diferença entre ele e o while."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "35vGIFteOop7",
        "colab_type": "text"
      },
      "source": [
        "## Mais sobre a função *range*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "39fvsD21Oop-",
        "colab_type": "text"
      },
      "source": [
        "A função `range` pode receber 1, 2 ou até 3 parâmetros. Em order, são esses:\n",
        "\n",
        "1. `start` - início da sequência\n",
        "2. `stop` - até onde a sequência deve ir (não é incluído na sequência gerada)\n",
        "3. `step` - intervalo entre os elementos da sequência (passo)\n",
        "\n",
        "Agora vamos ver alguns exemplos de utilização:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FIRTTsKPOoqA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "41e12bff-a650-481a-9633-51dd10cf3975"
      },
      "source": [
        "print (list(range(5)))"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YROpM0AaOoqH",
        "colab_type": "text"
      },
      "source": [
        "No exemplo acima, a função retornou uma sequência contendo 5 elementos, onde o primeiro é o 0 e o último 4."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "9wwMUHPlOoqI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "456c86fd-a37f-489b-e630-9b7a0d213dda"
      },
      "source": [
        "print (list(range(2, 7)))"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 3, 4, 5, 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f2HItmE2OoqQ",
        "colab_type": "text"
      },
      "source": [
        "No exemplo acima, definimos o parâmetro `start=2` e `stop=7` logo, o primeiro elemento foi o 2, enquanto o último elemento foi o 6, resultando em uma sequência que também contém 5 elementos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jqU9V5UNOoqS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "26fafa40-a5d8-467a-dfc7-f50d09eb1529"
      },
      "source": [
        "print (list(range(0, 12, 2)))"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 2, 4, 6, 8, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BFkQegBgOoqY",
        "colab_type": "text"
      },
      "source": [
        "No exemplo acima, definimos um intervalo de 2 à 12 e com o `step=2`. Logo, foi impressa uma sequência de 6 elementos, contida no intervalo entre 0 a 12, \"pulando\" de 2 em 2 elementos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a7yIFT4hOoqa",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4878f0b9-f408-4964-d9ff-5643d4826ce6"
      },
      "source": [
        "print (list(range(10, -1, -2)))"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10, 8, 6, 4, 2, 0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KNoXRkHpOoqi",
        "colab_type": "text"
      },
      "source": [
        "Também podemos utilizar um caminho de trás para frente na função *range*. No exemplo acima, definimos um intervalo de 10 até -1 (lembrando que o último elemento do fim do intervalo não é incluso na sequência gerada), e definimos o `step=-2`, ou seja, o resultado final foi uma sequência de 6 elementos, contida no intervalo de 10 a -1, \"decaindo\" de 2 em 2 elementos."
      ]
    }
  ]
}