03 - Controle de Fluxo, Exceções e Laços.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Controles de Fluxo\n",
    "\n",
    "## Introdução\n",
    "\n",
    "Como na maioria das linguagens, uma instrução condicional é definida com a seguinte estrutura:\n",
    "\n",
    "```python\n",
    "if <expressão booleana>:\n",
    "    <bloco de código caso a expressão seja verdadeira>\n",
    "else:\n",
    "    <bloco de código caso a expressão seja falsa>\n",
    "```\n",
    "\n",
    "Essa sintaxe possui dois pontos importantes:\n",
    "\n",
    "1. A abertura de cada bloco de código é dada pelo caractere `:`\n",
    "2. O que está dentro de cada bloco é dado pela presença de 4 espaços\n",
    "\n",
    "Observe a seguinte construção:\n",
    "\n",
    "```python\n",
    "lado de fora antes do if\n",
    "lado de fora antes do if\n",
    "lado de fora antes do if\n",
    "\n",
    "if <condicional>:\n",
    "    bloco do if parte 1\n",
    "    bloco do if parte 2\n",
    "    ...\n",
    "    bloco do if parte n\n",
    "    \n",
    "lado de fora depois do if\n",
    "lado de fora depois do if\n",
    "lado de fora depois do if\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N é par!\n"
     ]
    }
   ],
   "source": [
    "n = 2\n",
    "\n",
    "if n % 2 == 0:\n",
    "    print(\"N é par!\")\n",
    "else:\n",
    "    print(\"N é ímpar!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: Aquela checagem `== 0` é mesmo necessária? Você consegue reescrever o código sem ela?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos fazer checagem de sub strings usando o operador `in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "José está contido no nome!\n"
     ]
    }
   ],
   "source": [
    "nome = \"Joaquim José da Silva\"\n",
    "\n",
    "if \"José\" in nome:\n",
    "    print(\"José está contido no nome!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como em todas as expressões booleanas, ocorre o curto-circuito:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nenhum erro ocorreu graças ao curto circuito!\n"
     ]
    }
   ],
   "source": [
    "if n == 2 or 10 / 0:\n",
    "    print(\"Nenhum erro ocorreu graças ao curto circuito!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Falando de erros, vamos tratar exceções!\n",
    "\n",
    "## Exceções\n",
    "\n",
    "[Referência](https://docs.python.org/3/tutorial/errors.html)\n",
    "\n",
    "Quando alguma coisa dá errado em Python, ele nos joga uma exceção. Essas exceções podem — e devem! — ser capturadas e tratadas. Antes de fazermos esse tratamento, vamos dar uma olhada em como elas são:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-472b00a81c00>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mtchau\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"tchau\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0molá\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mtchau\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'"
     ]
    }
   ],
   "source": [
    "olá = \"olá\"\n",
    "tchau = \"tchau\"\n",
    "\n",
    "olá * tchau"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como Python não permite que a gente multiplique strings, ele nos deu um erro. No caso o tipo de erro é dado pelo nome `TypeError`. As exceções são acompanhadas de um texto que explica o que aconteceu — não podemos multiplicar sequências por alguma coisa que não é um número inteiro!\n",
    "\n",
    "**Não tenha medo de erros!**\n",
    "\n",
    "Muitas vezes quando estamos programando, nos deparamos com erros. Quando isso acontece, vale a pena parar, ler com calma o que a mensagem está dizendo, pensar um pouco, pesquisar, revisar o código... Por mais que possa ser um pouco desanimador termos a nossa tela avermelhada por uma mensagem de erro grande, muitas vezes essa mensagem nos dá pistas sobre o que está acontecendo, o que nos permite entendermos, corrigirmos e aprendermos. Abrace seus erros e faça as pazes com eles :D\n",
    "\n",
    "Outros exemplos de possíveis erros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-cd759d3fcf39>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m10\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "10 / 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-2342acfca396>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mnome\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Felipe\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mnome\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "nome = \"Felipe\"\n",
    "nome[10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'batata'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-71a230d929a0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"batata\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'batata'"
     ]
    }
   ],
   "source": [
    "int(\"batata\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`TypeError` significa que a operação que você quer usar existe, mas você está usando tipos de dados errados. `ZeroDivisionError` acontece em divisões por zero. `IndexError`, quando você tenta ir além dos limites de uma string ou lista. `ValueError` quando a variável é apropriada mas tem um valor incompatível. Uma lista completa dos erros que são definidos por padrão pode ser encontrada [aqui](https://docs.python.org/3/library/exceptions.html#bltin-exceptions)\n",
    "\n",
    "### Tratando exceções\n",
    "\n",
    "Se o seu programa encontrar uma exceção e não lidar com ela, ele vai parar. Python permite que você trate exceções utilizando a palavra reservada `try`. Seu uso completo é:\n",
    "\n",
    "```python\n",
    "try:\n",
    "    bloco de código que pode dar erro\n",
    "except:\n",
    "    o que fazer caso dê erro\n",
    "else:\n",
    "    o que fazer caso não dê erro\n",
    "finally:\n",
    "    bloco que vai ser executado indepente de qualquer coisa\n",
    "```\n",
    "\n",
    "Se você utilizar `except` sem argumentos, irá capturar *qualquer* tipo de exceção. Embora isso seja útil, é preferível capturar exceções bem definidas. Nesse caso, é possível especificar um ou mais tipos de exceção para serem tratadas:\n",
    "\n",
    "```python\n",
    "try:\n",
    "    <bloco>\n",
    "except TypeError:\n",
    "    <o que fazer caso ocorra TypeError>\n",
    "except ZeroDivisionError:\n",
    "    <o que fazer caso ocorra ZeroDivisionError>\n",
    "except:\n",
    "    <o que fazer caso um erro inesperado ocorra>\n",
    "```\n",
    "\n",
    "Vamos lidar com um erro de divisão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Não podemos dividir por zero!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    2 / 0\n",
    "except:\n",
    "    print(\"Não podemos dividir por zero!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vocês podem ver, a mensagem de erro original foi suprimida. Se estivessemos num programa longo, a execução seguiria normalmente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-6a3bd56eb25b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m2\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Não vou ser executado!\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "2 / 0\n",
    "print(\"Não vou ser executado!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Não posso dividir por zero!\n",
      "O erro foi tratado, o programa continua\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    2 / 0\n",
    "except ZeroDivisionError:\n",
    "    print(\"Não posso dividir por zero!\")\n",
    "    \n",
    "print(\"O erro foi tratado, o programa continua\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos interagir com o erro que ocorreu. No caso podemos colocar o erro numa variável e também podemos parar o programa!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encontrei o erro ''can't multiply sequence by non-int of type 'str''\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    \"oi\" * \"olá\"\n",
    "except Exception as e:\n",
    "    print(\"Encontrei o erro ''{}'\".format(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encontrei um erro! Vou lançar esse erro e parar tudo\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-c9a673cfd48e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[0mnome\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;32mexcept\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Encontrei um erro! Vou lançar esse erro e parar tudo\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    nome[20]\n",
    "except:\n",
    "    print(\"Encontrei um erro! Vou lançar esse erro e parar tudo\")\n",
    "    raise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python, toda exceção herda do tipo `Exception`. Se você quiser capturar uma exceção genérica dentro de uma variável, pode fazer algo do tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eu não sei bem o que aconteceu, mas a mensagem foi \"name 'olar' is not defined\"\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(olar)\n",
    "except Exception as e:\n",
    "    print(\"Eu não sei bem o que aconteceu, mas a mensagem foi \\\"{}\\\"\".format(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depois, veremos que é possível definir exceções customizadas e lançá-las no nosso programa\n",
    "\n",
    "### Silenciando exceções\n",
    "\n",
    "Podemos simplesmente ignorar uma exceção com a palavra reservada `pass`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finge que nada aconteceu, sorria e acene\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    n = i * t\n",
    "except:\n",
    "    pass\n",
    "\n",
    "print(\"Finge que nada aconteceu, sorria e acene\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É interessante notar que Python define a cláusula `else` para exceções. Isso é algo relativamente raro em linguagens e permite que um código seja executado apenas quando tudo aconteceu bem. É possível implementar essa mesma estrutura em outras linguagens, mas a utilização da cláusula `else` contribui para a legibilidade e modularização do código.\n",
    "\n",
    "Observe essa estrutura sem utilizar `else`, conforme poderia ser montada em outros cenários:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Foi possível dividir por n e o resultado é 2.0\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "try:\n",
    "    resultado = 20 / n\n",
    "    print(\"Foi possível dividir por n e o resultado é {}\".format(resultado))\n",
    "except:\n",
    "    print(\"n é um fator inválido!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Troque `n` por 0 e execute de novo. Como o erro ocorrre na linha `resultado = ...`, a execução para, a mensagem de resultado não é impressa e apenas a exceção é executada. Em um exemplo simples como esse, é fácil garantir tudo isso. Em situações mais complexas, isso nem sempre é verdade. Python permite uma estrutura assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Foi possível dividir por n e o resultado é 2.0\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "try:\n",
    "    resultado = 20 / n\n",
    "except:\n",
    "    print(\"n é um fator inválido!\")\n",
    "else:\n",
    "    print(\"Foi possível dividir por n e o resultado é {}\".format(resultado))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais uma vez, troque `n` por zero e observe. O comportamento é o mesmo! A vantagem é que agora nós podemos observar claramente que a linha de impressão de resultado vai ser executada _apenas_ se nenhum erro ocorreu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops\n",
    "\n",
    "Executar instruções de forma repetidada é uma outra construção necessária na estruturação de algoritmos. Python permite as construções `for`e `while` como de costume:\n",
    "\n",
    "```python\n",
    "for <expressão de interação>:\n",
    "    <bloco de código\n",
    "```\n",
    "\n",
    "```python\n",
    "while <expressão booleana>:\n",
    "    <bloco de código\n",
    "```\n",
    "\n",
    "Um loop clássico entre inteiros é feito com a função `range`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função [`range`](https://docs.python.org/3/library/stdtypes.html#range) permite a realização de iterações entre faixas de valores. Ela pode assumir argumentos opcionais que definem o início e o passo da iteração:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for i in range(10, 0, -1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício** Faça um loop que imprima todos os números pares de 0 a 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício** Faça um loop que imprima todos os números ímpares entre 100 e 0 em ordem decrescente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício** Faça um loop que imprima todos os números múltiplos de 7 entre 0 e 100. Tente resolver por dois caminhos diferentes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enquanto o loop `for` permite iterações entre valores — posteriormente veremos como iterar entre listas — o loop `while` verifica se uma expressão booleana é verdadeira entre as iterações do loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vou sortear inteiros de 0 a 100 até encontrar algum maior que 20!\n",
      "x ainda é menor que 20!\n",
      "x ainda é menor que 20!\n",
      "Encontrei um x maior que 20: 27\n",
      "Demorei 2 iteração(ões) para encontrar\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "x = 0\n",
    "iterações = 0\n",
    "\n",
    "print(\"Vou sortear inteiros de 0 a 100 até encontrar algum maior que 20!\")\n",
    "while x <= 20:\n",
    "    print(\"x ainda é menor que 20!\")\n",
    "    x = randint(0, 30)\n",
    "    iterações += 1\n",
    "\n",
    "print(\"Encontrei um x maior que 20: {}\".format(x))\n",
    "print(\"Demorei {} iteração(ões) para encontrar\".format(iterações))"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}