04-Iterações.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterações"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um programa de computador realmente brilha quando conseguimos criar um para realizar tarefas repetitivas, já que um computador consegue executar operações repetitivas mais eficientemente que nós humanos.\n",
    "\n",
    "Para isso, precisamos introduzir o conceito de **iteração**. Vamos supor que precisamos executar uma tarefa 4 vezes em que a aterefa está definida pela função abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def faca_tarefa():\n",
    "    print(\"Fazendo tarefa...\")\n",
    "    return 'concluído'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para executá-la 4 vezes, poderíamos executar a função 4 vezes seguidas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fazendo tarefa...\n",
      "Fazendo tarefa...\n",
      "Fazendo tarefa...\n",
      "Fazendo tarefa...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'concluído'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "faca_tarefa()\n",
    "faca_tarefa()\n",
    "faca_tarefa()\n",
    "faca_tarefa()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apesar de repetivo ter que escrever o mesmo texto quatro vezes, chamar esta função 4 vezes desta forma não é algo trabalhoso. E sempre podemos usar `CTRL+C/CTRL+V`. \n",
    "\n",
    "Porém, imagina se tivéssemos que executar isso 1347 vezes! Teríamos que digitar `CTRL+V` 1347 vezes e nosso programa teria 1347 linhas como o mesmo texto. Acho que podemos concordar que isso nos parece desnecessário. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O comando `for`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, para executar ações repetitivas, podemos usar o comando `for` do Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fazendo tarefa...\n",
      "Fazendo tarefa...\n",
      "Fazendo tarefa...\n",
      "Fazendo tarefa...\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2,3]:\n",
    "    faca_tarefa()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos que definimos a iteração de forma semelhante a funções: \n",
    "1. usamos a palavra reservada `for` para instruir o Python que estamos começando uma iteração,\n",
    "1. definimos uma variável `i` que receberá os valores da lista `[0,1,2,3]`. A escolha de `i` como variável é totalmente arbitrária; poderíamos ter escolhido qualquer outro nome.\n",
    "1. Colocamos o bloco de código identado.\n",
    "\n",
    "Podemos mostrar que a variável `i` recebe cada valor da lista em cada ciclo da iteração:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2,3]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ainda assim, seria trabalhoso ter que escrever uma lista com 1347 itens para criar a iteração. Para nos ajudar neste tópico, o Python possui uma função e objeto chamado `range` que cria um iterador para executarmos a iteração: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 4)\n"
     ]
    }
   ],
   "source": [
    "zero_ao_quatro = range(4)\n",
    "print(zero_ao_quatro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pela representação do objeto criado, vemos que já há alguma informação como o valor de ínicio `0` e fim `4`, não inclusivo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> E se escrevessemos `range(1,11,2)`? Isto funcionaria?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outro uso prático do `range` é para criar listas de números:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minha_lista = list(range(4))\n",
    "minha_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterando com `while`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra forma de iterar é com o comando `while` que repete uma rotina enquanto uma condição for verdadeira. Por exemplo, podemos implementar um contador regressivo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "valor = 5\n",
    "while valor >= 0:\n",
    "    print(valor)\n",
    "    valor -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aqui é crucial que a condição seja `False` em algum momento ou teremos uma iteração infinita."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém, em alguns casos é interessante criar uma iteração \"infinita\". Para isso, usamos o `while True`:\n",
    "\n",
    "```python\n",
    ">>> while True:\n",
    "...     print('foo')\n",
    "...\n",
    "foo\n",
    "foo\n",
    "foo\n",
    "  .\n",
    "  .\n",
    "  .\n",
    "foo\n",
    "foo\n",
    "foo\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 2, in <module>\n",
    "KeyboardInterrupt\n",
    "```\n",
    "\n",
    "Em que tive que usar o `Ctrl+c` para sair da iteração infinita.\n",
    "\n",
    "Apesar de um pouco bizarro, esta construção é utilizada em programas cuja ações são geradas a partir de requisições dadas por usuários ou outros sistemas como janelas gráficas e servidores web. \n",
    "\n",
    "Caso necessário, podemos forçar a saída da iteração usando um `break`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      ">  ls\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O comando dado foi ls\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      ">  exit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saindo\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    comando = input('> ')\n",
    "    if comando == 'exit':\n",
    "        print('saindo')\n",
    "        break\n",
    "    \n",
    "    print('O comando dado foi', comando)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursividade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível criar iterações usando recursividade:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contagem_regressiva(n):\n",
    "    if n == 0:\n",
    "        print(n)\n",
    "    else:\n",
    "        print(n)\n",
    "        contagem_regressiva(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "contagem_regressiva(5)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}