{ "cells": [ { "cell_type": "markdown", "id": "82a66505-fcd8-4b96-9b7b-30ff2bdc934d", "metadata": {}, "source": [ "# Repetições, repetições, repetições: loops em Python" ] }, { "cell_type": "markdown", "id": "b44c74c1-3db1-438f-964f-05961245ad58", "metadata": {}, "source": [ "## O que você saberá se você ler todo este capítulo?\n", "\n", "1. Que os laços (loops) ajudam a executar um mesmo pedaço de código várias vezes, e é muito melhor do que copiar e colar o mesmo código algumas vezes seguidas.\n", "2. Saberá que existem dois principais tipos de loops: \"para\" (`for`) e \"enquanto\" (`while`).\n", "3. Também entenderá que geralmente usamos o `for` quando sabemos exatamente quantas vezes queremos executar uma ação.\n", "4. Verá também que geralmente usamos o `while` quando queremos executar uma ação enquanto uma determinada condição for verdadeira (e não sabemos necessariamente com antecedência *quando* parar).\n", "5. Que é possível combinar `if` com loops.\n", "6. E, finalmente, que temos mais funções úteis em Python: no caso, a `range` para gerar sequências e a `len` para medir o tamanho de palavras ou de listas (e que veremos mais sobre listas em breve)." ] }, { "cell_type": "markdown", "id": "070beb26-b7c5-4b17-8fa9-f51fc21e35a1", "metadata": {}, "source": [ "## Explicando loops com bolos e brigadeiros\n", "\n", "Lembra quando introduzimos o conceito de algoritmos com uma receita de bolo? Vamos agora pensar em uma receita de brigadeiros. O que acha?\n", "\n", "
\n", " \"Imagem\n", "
Brigadeiros. Servido? Créditos: Mayra Chiachia, no Flickr.
\n", "
" ] }, { "cell_type": "markdown", "id": "ec21ea94-96ac-43fd-880c-f976879ba35f", "metadata": {}, "source": [ "---\n", "##### Ingredientes\n", "\n", "- 1 lata de leite condensado\n", "- 2 colheres (sopa) de cacau em pó\n", "- 1 colher (sopa) de manteiga sem sal\n", "- Granulado de chocolate para cobrir\n", "\n", "##### Modo de preparo\n", "\n", "1. Em uma panela, adicione o leite condensado, o cacau em pó e a manteiga sem sal.\n", "2. Leve a panela ao fogo baixo e mexa sem parar até que a mistura comece a soltar do fundo da panela.\n", "3. Desligue o fogo e continue mexendo a mistura até que ela esfrie um pouco.\n", "4. Coloque o granulado em um prato.\n", "5. Enquanto ainda tiver mistura sobrando, faça:\n", "6.     *Pegue uma pequena porção da mistura e faça uma bolinha do tamanho de uma cereja.*\n", "7.     *Passe a bolinha de brigadeiro no granulado, cobrindo-a completamente.*\n", "8.     *Coloque a bolinha em uma forma.*\n", "9. No final, coloque as bolinhas em forminhas de papel ou em um prato para servir.\n", "\n", "##### Resultado esperado\n", "Brigadeiros cobertos com granulado de chocolate.\n", "\n", "---" ] }, { "cell_type": "markdown", "id": "c0fa1323-3263-4360-acd2-c0e4873fc279", "metadata": {}, "source": [ "Agora, imagine outro exemplo - agora, com bolo. Você está preparando uma receita de bolo de chocolate e precisa misturar os ingredientes até obter uma massa homogênea. Neste exemplo, é necessário utilizar um loop (uma repetição) para misturar os ingredientes secos de forma adequada e obter uma mistura homogênea. Esta repetição trata dos mesmos passos para todos os ingredientes: no caso, colocar em uma tigela e misturar com os demais ingredientes.\n", "\n", "Percebeu algo parecido entre o exemplo do brigadeiro e o bolo? A **repetição**. No caso do bolo, nós estaríamos repetindo a mesma operação de colocar um ingrediente em uma tigela e misturar com os demais por algumas vezes.\n", "\n", "Agora, preste atenção nos passos 6, 7 e 8 da receita de brigadeiro. Você consegue se enxergar repetindo aqueles passos por várias e várias vezes até a massa de brigadeiro acabar? Dependendo de quem faz (e da fome), poderíamos fazer com 10 brigadeiros grandes ou 50 brigadeiros pequenos - independentemente disso, iremos por algumas vezes repetir os passos 6, 7 e 8 em sequência. Se fôssemos colocar um exemplo de como alguém percorreria estes passos sairia algo mais ou menos assim:\n", "\n", "`1-2-3-4-5-6-7-8-6-7-8-6-7-8-6-7-8-6-7-8-6-7-8-6-7-8-6-7-8-6-7-8-9-10`." ] }, { "cell_type": "markdown", "id": "5d310647-27c4-4995-b6d9-ddb53f3d73d0", "metadata": {}, "source": [ "## Um exemplo em Python\n", "\n", "E como este tipo de operação seria no Python? Melhor: como as coisas *não* seriam com o uso de loops? Imagine criar um algoritmo que mostre na tela todos os números de 1 a 10. Fácil, né? Olha só:\n", "\n", "```python\n", "print(1)\n", "print(2)\n", "print(3)\n", "print(4)\n", "print(5)\n", "print(6)\n", "print(7)\n", "print(8)\n", "print(9)\n", "print(10)\n", "```\n", "\n", "E se eu pedisse a você para mudar este código para mostrar todos os números de 1 a 1000? Aí complica, né?" ] }, { "cell_type": "markdown", "id": "857b2dd6-d8b1-434d-aef2-28330af3e644", "metadata": {}, "source": [ "## Repetições com `for` (\"para\") e `while` (\"enquanto\")\n", "As **estruturas de repetição** como o `para` e `enquanto` servem para resolver problemas como esse cenário de mostrar todos os números de 1 a 1000 de forma inteligente ao executar um conjunto de instruções várias vezes, sem que tenhamos que repetir na mão todas essas instruções.\n", "\n", "Vamos imaginar um cenário em que precisamos caminhar por um trajeto pré-determinado ou explorar uma área desconhecida.\n", "\n", "O *\"para\"* é como caminhar por um trajeto conhecido, onde você sabe onde está o ponto de partida e o ponto de chegada. Você pode contar o número de passos e ter uma ideia de quanto tempo levará para chegar ao destino. Na programação, isso significa que você usa o *\"para\"* **quando sabe exatamente quantas vezes quer executar uma ação**.\n", "\n", "Já o *\"enquanto\"* é como explorar uma área desconhecida, onde você não sabe exatamente onde está indo, mas continua caminhando enquanto houver caminho. Na programação, isso significa que você usa o *\"enquanto\"* **quando quer executar uma ação enquanto uma determinada condição for verdadeira**.\n", "\n", "> 📝 Em resumo, o \"para\" é usado quando você sabe quantas vezes precisa fazer algo, enquanto o \"enquanto\" é usado quando não se sabe quantas vezes precisa fazer algo, mas sabe quando parar.\n", "\n", "Veja como seria o uso do *\"para\"* em pseudocódigo para escrever todos os números de 1 a 1000 na tela:\n", "\n", "```bash\n", "1. Início\n", "2. Inteiro: i\n", "3.\n", "4. Para todo i de 1 até 1000, faça:\n", "5. Escreva(i)\n", "6. Fim Para\n", "7. Fim\n", "```\n", "\n", "Aqui, observe que existe uma variável chamada `i`. Este nome é uma convenção comum usada em loops para representar um índice ou contador. O nome `i` é uma abreviação de *índice* e é frequentemente usado em loops para rastrear a posição atual na sequência que está sendo iterada. Por exemplo, no código acima o `i` começará com o valor de `1` na linha 4, e escreverá este valor na tela com a linha 5. Depois, **voltamos para a linha 4** e incrementamos em um o valor de `i`, que agora vale `2`, e mostraremos este valor na linha 5. Depois, **voltamos novamente para a linha 4** e incrementamos `i`, que agora vale `3`, e mostraremos este valor na linha 5. Repetiremos isto até chegar ao valor de `1000`, mostrando-o na tela. Após alcançar o `1000` finalmente iremos para a linha 6, saindo do loop e encerrando o código.\n", "\n", "Agora, veja o uso do *\"enquanto\"* para resolver o mesmo problema:\n", "\n", "```bash\n", "1. Início\n", "2. Inteiro: i\n", "3.\n", "4. i = 1\n", "5. Enquanto i <= 1000, faça:\n", "6. Escreva(i)\n", "7. i = i + 1\n", "8. Fim Enquanto\n", "9. Fim\n", "```\n", "\n", "Aqui, na linha 4 inicializamos o `i` para valer 1. Enquanto a condição da linha 5 for verdadeira iremos percorrer as linhas 6 e 7 infinitamente: como `i` agora vale 1, a condição da linha 5 é verdade. Com isso, vamos para a linha 6 (mostrando `1` na tela) e incrementamos o valor de `i`, que agora vale `2`. Agora, **voltamos para a linha 5**. A condição ainda é verdade, já que 2 é menor do que 1000. Com isso, vamos à linha 6 (mostrando `2` na tela) e incrementamos novamente o valor de `i`, que agora vale `3`. Assim, vamos sucessivamente até chegar ao 1000. Após mostrar `1000` na tela, incrementamos novamente o valor de `i`, que agora vale `1001`. Com isso, **voltamos para a linha 5**. Agora, a condição é falsa, já que 1001 não é maior ou igual a 1000. Como é falsa, finalmente sairemos do loop e pularemos as linhas 6 e 7, indo diretamente para a linha 8 e finalizando o código." ] }, { "cell_type": "markdown", "id": "0cecfdc1-27b5-4514-9b36-07306f8e4d39", "metadata": {}, "source": [ "### `for`\n", "\n", "Em Python, o *\"para\"* se chama `for`. Lembra daquele problema de mostrar na tela todos os números de 1 a 1000? Olha como isso ficaria usando `for`:\n", "\n", "```python\n", "for i in range(1, 1001):\n", " print(i)\n", "```\n", "\n", "A estrutura `for` é usada em Python quando temos que executar um bloco de código um número específico de vezes, baseado em uma sequência de valores. No exemplo acima, o loop vai executar mil vezes, uma vez para cada número na sequência. Lemos aquele `for i in range(1, 1001)` como *\"Para todo `i` que está no intervalo de 1 a 1000, faça:\"*.\n", "\n", "> 🔄 ***Função*** `range()`: Nesse caso, a função `range()`, que gera automaticamente uma sequência de números inteiros de acordo com os parâmetros fornecidos. No exemplo acima, a sequência começa em 1 e termina em 1000 (o número final não é incluso: um jeito de ler aquele `range(1, 1001)` seria *\"gere uma sequência de valores de 1 até 1001, mas sem contar o 1001.\"*). Experimente como funcionaria aquele código com `range(1, 1001, 2)` e `range(-1000, 1)`.\n", "\n", "#### Exemplos\n", "Bom, o que acha de colocar a mão na massa com alguns exemplos? Recomendo que você teste comigo todos estes códigos no seu PyCharm. Se possível use o debugger para entender o que está acontecendo com o código a cada linha executada. Vamos lá?\n", "\n", "#### Soma de 1 a 10\n", "Este é um código que tem como objetivo calcular a soma dos números inteiros de 1 a 10 e mostrar o resultado na tela:\n", "\n", "```python\n", "soma = 0\n", "for num in range(1, 11):\n", " soma += num\n", "print(\"A soma dos números é:\", soma)\n", "```\n", "\n", "Primeiramente, é criada uma variável chamada `soma` e atribuído o valor zero a ela. Em seguida, é utilizado o loop `for` para percorrer todos os números de 1 a 10, representados pela função `range(1, 11)` (lembra que eu falei que o último número desse `range` não é considerado, né? Seria um *\"de 1 até 11, mas sem contar o 11\"*. A cada iteração do loop, o número é adicionado à variável `soma` por meio do operador `+=`. `soma += num` é outra forma de escrever `soma = soma + num`, mas de um jeito mais curto.\n", "\n", "Ao final do loop, a variável `soma` terá armazenado a soma de todos os números de 1 a 10. Então, a função `print()` é usada para mostrar a mensagem *\"A soma dos números é:\"* seguida do valor da variável `soma`.\n", "\n", "#### Soma de 10 a 50\n", "E se não quiséssemos usar `range()`, ou se tivéssemos um conjunto de números que não fossem necessariamente uma sequência? Também podemos usar o `for` para isso. Veja e rode o código abaixo em seu computador:\n", "\n", "```python\n", "numeros = [10, 25, 1, 40, -4]\n", "soma = 0\n", "for num in numeros:\n", " soma += num\n", "print(\"A soma dos números é:\", soma)\n", "```\n", "\n", "O código acima começa criando uma lista de números, chamada `numeros`, contendo 5 elementos. Sabemos que é uma lista porque é um conjunto de valores delimitados por colchetes (`[]`) e separados por vírgulas.\n", "\n", "> 🐱‍🏍 *Fique tranquilo! Um pouco depois deste capítulo iremos nos aprofundar em listas.*\n", "\n", "Em seguida, é criada uma variável chamada `soma` com valor inicial igual a 0.\n", "\n", "O loop for percorre cada elemento da lista `numeros`, e para cada elemento, o valor é adicionado à variável `soma`. Ou seja, o loop está somando cada número da lista. Primeiro, ele soma o valor 10, que é o primeiro elemento da lista. Depois, soma o 25. Depois, o 1. Depois, o 40. Finalmente, o -4.\n", "\n", "Por fim, o programa imprime a mensagem *\"A soma dos números é:\"* seguida do valor da variável `soma`, que é a soma total dos elementos da lista `numeros`.\n", "\n", "#### Quadrado\n", "Agora, e se fôssemos calcular o quadrado de cada número de uma sequência? Veja só:\n", "\n", "```python\n", "numeros = [1, 2, 3, 4, 5]\n", "for num in numeros:\n", " quadrado = num ** 2\n", " print(quadrado)\n", "```\n", "\n", "O código acima começa criando uma lista de números chamada `numeros`, contendo os valores de 1 a 5. Em seguida, é utilizado um loop `for` para percorrer cada um dos números da lista.\n", "\n", "Para cada número, o loop realiza o cálculo do quadrado do número através da operação de exponenciação com o operador `**`, atribuindo o resultado à variável `quadrado`. Depois, o loop imprime na tela o valor de \"quadrado\" correspondente a cada número da lista. A cada loop este valor de `quadrado` é sobrescrito (substituído) com um novo valor.\n", "\n", "Dessa forma, o código irá imprimir os valores dos quadrados dos números de 1 a 5, ou seja: `1`, `4`, `9`, `16` e `25`.\n", "\n", "#### Percorrendo strings\n", "Sabia que também podemos usar o `for` em strings? E se quiséssemos mostrar todas as letras do seu nome com uma letra a cada linha? Então teste este código:\n", "\n", "```python\n", "nome = input(\"Digite o seu nome: \")\n", "\n", "for letra in nome:\n", " print(letra)\n", "```\n", "\n", "O código acima começa solicitando ao usuário que digite seu nome e armazena esse nome na variável `nome`. Em seguida, é iniciado um loop for que vai percorrer cada letra contida na variável `nome`.\n", "\n", "A cada iteração do loop, a variável `letra` recebe a próxima letra contida em `nome`, que é então impressa com a função `print(letra)`. O resultado final é a impressão de cada letra do nome digitado pelo usuário em uma linha separada.\n", "\n", "Por exemplo, se o usuário digitar *\"Maria\"*, o resultado mostrado na tela será:\n", "\n", "```bash\n", "M\n", "a\n", "r\n", "i\n", "a\n", "```\n", "\n", "#### Percorrendo listas de palavras\n", "E se quiséssemos percorrer uma lista de palavras e verificar se alguma delas contém a letra `r`? Olha só:\n", "\n", "```python\n", "for palavra in [\"casa\", \"amor\", \"árvore\", \"abacaxi\"]:\n", " if 'r' in palavra:\n", " print(palavra)\n", "```\n", "\n", "A estrutura `for palavra in [\"casa\", \"amor\", \"arvore\", \"abacaxi\"]:` indica que o loop irá percorrer cada palavra da lista `[\"casa\", \"amor\", \"arvore\", \"abacaxi\"]`.\n", "\n", "Dentro do loop, a condição `if 'r' in palavra:` verifica se a letra `\"r\"` está presente (está dentro) em cada palavra. Se estiver, o `print(palavra)` será executado, exibindo a palavra que contém a letra `\"r\"`.\n", "\n", "Portanto, ao executar esse código, serão exibidas as palavras \"amor\" e \"arvore\", que são as palavras da lista que possuem a letra `\"r\"`.\n", "\n", "Esse tipo de estrutura é muito útil para **filtrar** informações em uma lista, de acordo com uma condição específica. Ah, percebeu também que estamos começando a combinar `if` com `for`? Pois bem: esta flexibilidade no uso de diferentes estruturas em desenvolvimento de software é o que contribui para que os códigos sejam tão poderosos para resolver diferentes tipos de problemas.\n", "\n", "#### Filtrando números pares\n", "Para fechar: como seria um código que pudesse percorrer uma sequência de números e mostrar na tela somente aqueles que fossem pares? Veja só:\n", "\n", "```python\n", "for num in range(1, 21):\n", " if num % 2 == 0:\n", " print(num, \" é um número par\")\n", "```\n", "\n", "Este código mostrará na tela apenas os números pares dentro de um intervalo de 1 a 20. A linha `for num in range(1, 21):` cria um loop que percorre todos os números de 1 a 20, atribuindo cada um deles à variável `num`, um de cada vez.\n", "\n", "Em seguida, o `if` verifica se o número é par, o que é feito usando o operador módulo `%`. Se o resto da divisão do número por 2 for igual a zero, isso significa que o número é par. Caso contrário, ele é ímpar e será ignorado pelo código.\n", "\n", "Por fim, a linha `print(num, \" é um número par\")` imprime o número par encontrado." ] }, { "cell_type": "markdown", "id": "cc6e1643-c5d7-4fab-a5d5-47303e8fcb40", "metadata": {}, "source": [ "### `while`\n", "\n", "Em Python, o *\"enquanto\"* se chama `while`. Aquele problema de mostrar na tela todos os números de 1 a 1000 usando o `while` ficaria assim:\n", "\n", "```python\n", "i = 1\n", "while i <= 1000:\n", " print(i)\n", " i += 1\n", "```\n", "\n", "Este código começa definindo uma variável chamada `i` com o valor inicial de 1. Em seguida, ele entra em um loop que continuará enquanto `i` for menor ou igual a 1000.\n", "\n", "Dentro do loop, ele executa a ação de imprimir o valor de `i` e, em seguida, **incrementa o valor de `i` em 1**. Agora, queria chamar a sua atenção para isso: experimente testar o seu código *sem* usar aquela linha `i += 1` (que é a mesma coisa de `i = i + 1`): o loop se repetiria infinitamente e imprimiria o número 1 infinitamente. Isto acontece porque, sem esta linha, o número em `i` jamais mudaria e ficaríamos infinitamente executando o `print(i)` porque a condição `i <= 1000` seria para sempre verdade.\n", "\n", "Ah, e como comentei antes, o `while` é usado quando **não se sabe exatamente** quantas vezes um loop precisa ser executado. Ele continuará executando até que a condição seja falsa. Neste exemplo, a condição é `i <= 1000`, o que significa que o loop continuará até que `i` seja maior que 1000.\n", "\n", "#### Soma de 1 a 10\n", "Como seria aquele código que mostra a soma de todos os números de 1 a 10 que já vimos antes com o `for`, mas com o `while` no lugar? Veja e teste:\n", "\n", "```python\n", "i = 1\n", "soma = 0\n", "while i <= 10:\n", " soma += i\n", " print(soma)\n", " \n", " i += 1\n", "```\n", "\n", "No início e *antes* de entrar no loop, a variável `i` é iniciada com o valor de 1 e a variável `soma` com o valor de 0 (até porque não somamos nada até agora). A condição do loop é que a variável `i` seja menor ou igual a 10. Enquanto essa condição for verdadeira, o código dentro do loop será executado.\n", "\n", "Dentro do loop, primeiro fazemos a soma do valor atual de `i` com o que já estava armazenado na variável `soma`, e mostramos isto na tela. Em seguida, a variável `i` é incrementada em 1 unidade com a linha `i += 1`. O loop é encerrado quando a variável `i` atingir o valor 11, pois a condição do loop deixará de ser verdadeira. Portanto, o resultado na tela será a soma da sequência numérica de 1 a 10, com cada número em uma linha diferente. O funcionamento será assim:\n", "1. Primeiro passo: `soma` (0) + `i` (1) = 1, que passará a ser o novo valor de `soma`.\n", "2. Segundo passo: `soma` (1) + `i` (2) = 3, que passará a ser o novo valor de `soma`.\n", "3. Terceiro passo: `soma` (3) + `i` (3) = 6, que passará a ser o novo valor de `soma`.\n", "4. Quarto passo: `soma` (6) + `i` (4) = 10, que passará a ser o novo valor de `soma`.\n", "5. Quinto passo: `soma` (10) + `i` (5) = 15, que passará a ser o novo valor de `soma`.\n", "6. Sexto passo: `soma` (15) + `i` (6) = 21, que passará a ser o novo valor de `soma`.\n", "7. Sétimo passo: `soma` (21) + `i` (7) = 28, que passará a ser o novo valor de `soma`.\n", "8. Oitavo passo: `soma` (28) + `i` (8) = 36, que passará a ser o novo valor de `soma`.\n", "9. Nono passo: `soma` (36) + `i` (9) = 45, que passará a ser o novo valor de `soma`.\n", "10. Décimo passo: `soma` (45) + `i` (10) = 55, que passará a ser o novo valor de `soma`.\n", "\n", "#### Testando uma senha\n", "E um algoritmo simples para validar uma senha e que só mostre a frase *\"Acesso permitido!\"* somente depois do usuário informar uma senha correta? Veja:\n", "\n", "```python\n", "senha = \"\"\n", "while senha != \"12345\":\n", " senha = input(\"Digite a senha: \")\n", "print(\"Acesso permitido!\")\n", "```\n", "\n", "O código acima cria um loop usando a estrutura `while` que pede ao usuário que digite uma senha. Ele mantém o loop enquanto a senha digitada não for igual à string `\"12345\"`. Enquanto o usuário não digitar a senha correta, ele solicitará para que o usuário insira a senha e armazena a entrada em uma variável chamada `senha`. Se a senha estiver correta e for igual a `\"12345\"`, o loop é interrompido e a mensagem *\"Acesso permitido!\"* é exibida. Se a senha digitada não for igual a `\"12345\"`, o loop continuará a pedir que o usuário insira a senha correta infinitamente.\n", "\n", "#### Fazendo um menu\n", "E o que acha de fazer um menu bonitão para o usuário? Com o `while`, isto é possível. Veja:\n", "\n", "```python\n", "opcao = ''\n", "while opcao != 's':\n", " print(\"MENU:\")\n", " print(\"a. Opção 1\")\n", " print(\"b. Opção 2\")\n", " print(\"c. Opção 3\")\n", " print(\"s. Sair\")\n", " opcao = input(\"Digite uma opção: \")\n", " if opcao == 'a':\n", " print(\"Opção 1 selecionada\")\n", " elif opcao == 'b':\n", " print(\"Opção 2 selecionada\")\n", " elif opcao == 'c':\n", " print(\"Opção 3 selecionada\")\n", " elif opcao == 's':\n", " print(\"Saindo...\")\n", " else:\n", " print(\"Opção inválida.\")\n", "```\n", "\n", "Este código mostra um menu para o usuário e permite que ele selecione uma opção digitando a letra correspondente à opção. O programa entra em um loop enquanto o usuário não digita a opção `\"s\"` (sair). Em cada iteração do loop, o programa imprime o menu e solicita ao usuário que digite uma opção. Depois disso, o programa verifica qual opção foi selecionada pelo usuário e executa a ação correspondente. Se o usuário selecionar a opção `\"s\"`, o programa encerra o loop e imprime a mensagem *\"Saindo...\"*. Se o usuário selecionar uma opção inválida, o programa imprime a mensagem *\"Opção inválida.\"* e retorna ao início do loop para apresentar o menu novamente e aguardar uma nova seleção do usuário.\n", "\n", "> 👉 Pontos importantes neste código: veja que há uma combinação de `while` e `if`/`elif`/`else`. Experimente remover por completo o `else`: como seria a experiência do usuário em não se ter nenhuma mensagem apresentada para ele quando ele digita uma opção inválida? Talvez sejam em casos assim em que a utilidade do `else` fique mais clara para você.\n", "\n", "#### Testando números positivos e negativos\n", "Agora, vamos imaginar um código em que pediremos para que o usuário digite um número. Se o número for zero, sairemos do programa. Enquanto não for zero, testaremos se aquele número é positivo ou negativo, mostraremos este resultado na tela, e pediremos por um outro número logo em seguida. Veja e teste:\n", "\n", "```python\n", "num = int(input(\"Digite um número (digite 0 para sair): \"))\n", "while num != 0:\n", " if num > 0:\n", " print(\"O número é positivo\")\n", " else:\n", " print(\"O número é negativo\")\n", " num = int(input(\"Digite outro número (digite 0 para sair): \"))\n", "```\n", "\n", "O código começa pedindo ao usuário para digitar um número e armazena essa entrada na variável `num`. Em seguida, o código entra em um loop `while` que só será interrompido quando o usuário digitar o número `0`. Dentro desse loop, o código verifica se o número digitado é maior que zero (positivo) ou menor que zero (negativo), imprimindo a mensagem correspondente na tela.\n", "\n", "Em seguida, o código pede ao usuário para digitar outro número e armazena a entrada na variável `num` novamente. Esse processo continua até que o usuário digite zero e, assim, interrompa o loop.\n", "\n", "O uso do while é importante aqui, pois permite que o código continue pedindo novos números **até que o usuário decida sair, sem que seja necessário determinar previamente quantas vezes o loop será executado**.\n", "\n", "#### Inserindo notas válidas\n", "Lembra dos exemplos com notas que vimos no capítulo anterior? Em nenhum momento testamos casos em que a nota era menor do que 0 ou maior do que 10, certo? O que acha de usarmos o `while` para **validar** o que o usuário digitou, garantindo assim que ele informe apenas valores válidos? Teste isto:\n", "\n", "```python\n", "nota = -1\n", "while nota < 0 or nota > 10:\n", " nota = float(input(\"Digite uma nota entre 0 e 10: \"))\n", "print(\"Nota válida:\", nota)\n", "```\n", "\n", "Esse código solicita ao usuário que digite uma nota entre 0 e 10. Caso a nota digitada não esteja dentro desse intervalo, o programa continuará pedindo para que o usuário digite uma nota válida. Esse processo é feito por meio de um loop `while`. Para testar este código, tente informar notas inválidas como `1000`, `-5` e `1234`. Veja que o programa irá rejeitar estas notas. Se você testar letras no lugar de números você verá um erro bem feio (resolveremos isso mais adiante, também).\n", "\n", "Na primeira linha do loop, a variável `nota` é inicializada com o valor -1. Em seguida, a expressão `nota < 0 or nota > 10` verifica se a nota digitada está dentro do intervalo desejado. Se a nota não estiver dentro desse intervalo, o loop continuará executando e pedindo para que o usuário digite outra nota válida.\n", "\n", "Quando o usuário finalmente digita uma nota válida, o loop para de ser executado e o programa imprime a mensagem *\"Nota válida:\"* seguida da nota digitada." ] }, { "cell_type": "markdown", "id": "f62b8572-22ce-4bbc-a4a2-8144f8dcbab1", "metadata": {}, "source": [ "## Exercícios\n", "Neste momento eu espero que você já tenha entendido como funciona (de maneira geral) o `for` e o `while`. O que acha de colocar a mão na massa e experimentar?\n", "\n", "1. Crie um algoritmo que pede ao usuário para que digite um número inicial e um número final. Em seguida, ele mostrará todos os números pares neste intervalo usando `for`.\n", " - Exemplo: um usuário digita os números `1` e `10`. O algoritmo deve retornar várias mensagens falando que os números 2, 4, 6, 8 e 10 são pares.\n", "2. Crie um algoritmo que solicita ao usuário que insira um número e exibe na tela se ele é primo ou não usando o `for`.\n", " - Exemplo: um usuário digita o número `53`. O algoritmo deve retornar a mensagem *\"53 é um número primo\"*.\n", "3. Crie um algoritmo que mostra todos números de 5 a -5 usando o for.\n", " - Exemplo: o algoritmo deve mostrar na tela e na ordem correta: `5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5`. Pode ser mostrado um número por linha.\n", "4. Crie um algoritmo para calcular o fatorial de um número usando o for.\n", " - Exemplo: um usuário digita `5`. O algoritmo deve retornar `120` ($5! = 5 * 4 * 3 * 2 * 1 = 120$).\n", "5. Escreva um algoritmo para verificar se uma palavra é um palíndromo usando o `while`.\n", " - Exemplo: `radar` é um palíndromo (se ler a palavra de trás para frente resultará na mesma palavra). `banana` não é um palíndromo." ] }, { "cell_type": "markdown", "id": "6eb1958e-d357-4e03-9e7c-17f34c05a5ee", "metadata": {}, "source": [ "### Respostas" ] }, { "cell_type": "markdown", "id": "61e344a8-5f18-445d-81b1-c3268ccf2eed", "metadata": {}, "source": [ "**1. Crie um algoritmo que pede ao usuário para que digite um número inicial e um número final. Em seguida, ele mostrará todos os números pares neste intervalo usando `for`.**\n", "\n", "```python\n", "inicio = int(input(\"Insira um número para começar a contagem: \"))\n", "fim = int(input(\"Insira um número para terminar a contagem: \"))\n", "\n", "for num in range(inicio, fim+1):\n", " if num % 2 == 0:\n", " print(num, \"é um número par\")\n", "```\n", "\n", "O código acima pede ao usuário para inserir dois números, um para começar a contagem (`inicio`) e outro para terminar a contagem (`fim`). Em seguida, ele utiliza um loop for que percorre cada número no intervalo entre o número em `inicio` e `fim`. Como o `range()` retorna uma sequência sem considerar o último número no segundo parâmetro, colocamos o `fim+1` para que a sequência termine em `fim`.\n", "\n", "Dentro do loop, há uma verificação para determinar se o número é par ou não. Se o número for par, o programa exibe o número e uma mensagem informando que ele é par. Caso contrário, o loop continua para o próximo número.\n", "\n", "O operador `%` é utilizado para verificar se o número é par. O operador `%` retorna o resto da divisão entre dois números. Se o resto da divisão por 2 for 0, então o número é par.\n", "\n", "Por exemplo, se o usuário inserir 1 como número inicial e 10 como número final, o programa irá percorrer os números 1, 2, 3, 4, 5, 6, 7, 8, 9 e 10. Dentre esses números, somente 2, 4, 6, 8 e 10 são pares e, portanto, serão exibidos na tela acompanhados da mensagem *\"é um número par\"*." ] }, { "cell_type": "markdown", "id": "c35e05f8-e3f6-428b-85ba-d7605602e928", "metadata": {}, "source": [ "**2. Crie um algoritmo que solicita ao usuário que insira um número e exibe na tela se ele é primo ou não usando o `for`.**\n", "\n", "```python\n", "num = int(input(\"Digite um número: \"))\n", "primo = True\n", "\n", "for i in range(2, num):\n", " if num % i == 0:\n", " primo = False\n", " break\n", "\n", "if primo:\n", " print(num, \"é um número primo\")\n", "else:\n", " print(num, \"não é um número primo\")\n", "```\n", "\n", "Primeiro, o usuário é solicitado a digitar um número e essa entrada é armazenada na variável `num`. Em seguida, é criada uma variável booleana `primo` com valor inicial `True`. Isto garantiria que casos como `num = 2` funcionariam ainda que pulássemos o loop.\n", "\n", "Dito isso, depois desta linha é criado um loop `for` que itera sobre todos os números de 2 até `num-1`. Para cada número `i` dentro desse intervalo, é verificado se `num` é divisível por `i` usando o operador `%` (que retorna o resto da divisão). Se a condição `num % i == 0` for verdadeira, então `num` não é um número primo e a variável `primo` é atualizada para `False`. \n", "\n", "> 👉 Veja que este exemplo possui a palavra-chave `break`. Esta palavra serve para interromper a execução do loop imediatamente naquela linha, e tem a intenção de evitar testes desnecessários. Por exemplo: 1000 não é um número primo. Logo, não faria sentido testar com todos os números de 2 a 999 se já percebermos que ele é divisível por 2 e, portanto, não seria um número primo.\n", "\n", "Finalmente, o código verifica o valor da variável `primo` com um `if`. Se ela ainda for `True`, isso significa que o número é primo e uma mensagem é impressa na tela indicando isso. Caso contrário, é impressa uma mensagem indicando que o número não é primo." ] }, { "cell_type": "markdown", "id": "e60f5116-a32b-4a06-90fc-a04a7ef3ac23", "metadata": {}, "source": [ "**3. Crie um algoritmo que mostra todos números de 5 a -5 usando o for.**\n", "\n", "```python\n", "for i in range(5, -6, -1):\n", " print(i)\n", "```\n", "\n", "O código acima usa o loop `for` para percorrer um intervalo de números decrescente, de 5 até -5 (incluindo o zero), de um em um. Isso é feito usando a função `range()` com três argumentos:\n", "- Primeiro argumento: o valor inicial (5).\n", "- Segundo argumento: o valor final (-6).\n", "- Terceiro argumento: como devemos percorrer do valor inicial para o final (no caso, avançando de -1 em -1).\n", "\n", "Ou seja, o loop começa com `i` igual a 5, imprime o valor e, em seguida, diminui `i` em 1, repetindo esse processo até que `i` chegue a -6 e o loop seja encerrado.\n", "\n", "Dessa forma, o código imprimirá na tela os números de 5 a -5, nessa ordem: `5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5`." ] }, { "cell_type": "markdown", "id": "f6b87c33-af51-4b16-a4c2-44361479cb82", "metadata": {}, "source": [ "**4. Crie um algoritmo para calcular o fatorial de um número usando o for.**\n", "\n", "Lembrando mais uma vez da premissa: o fatorial é o resultado da multiplicação de um número inteiro por todos os seus antecessores positivos. Por exemplo, o fatorial de 5 é `5 * 4 * 3 * 2 * 1`, que resulta em 120. Isto posto, vamos ao código:\n", "\n", "```python\n", "num = int(input(\"Digite um número: \"))\n", "\n", "fatorial = 1\n", "for i in range(1, num+1):\n", " fatorial *= i\n", "\n", "print(\"O fatorial de\", num, \"é\", fatorial)\n", "```\n", "\n", "Na primeira linha, o programa pede ao usuário para inserir um número, armazenando o mesmo em uma variável chamada `num`. Em seguida, o programa cria uma variável `fatorial` e atribui o valor 1 a ela. Isso é necessário porque a multiplicação por zero sempre resulta em zero, então é necessário começar com um valor diferente de zero.\n", "\n", "Em seguida, o programa entra em um loop for que vai de 1 até o número digitado pelo usuário. A cada iteração do loop, o valor de `i` é multiplicado pelo valor de fatorial (`fatorial *= i` é a mesma coisa de `fatorial = fatorial * i`). Quando o loop termina, a variável `fatorial` contém o fatorial do número digitado pelo usuário.\n", "\n", "Por fim, o programa exibe na tela o resultado da operação, informando o número digitado e o seu fatorial correspondente." ] }, { "cell_type": "markdown", "id": "762a041b-045f-41ba-aa4c-d8d8106495b2", "metadata": {}, "source": [ "**5. Escreva um algoritmo para verificar se uma palavra é um palíndromo usando o `while`.**\n", "\n", "Sei que este aqui é bem mais difícil e complexo. Na verdade, a ideia é muito mais a de compartilhar funcionalidades novas. Teste isto:\n", "\n", "```python\n", "palavra = input(\"Digite uma palavra: \")\n", "i = 0\n", "j = len(palavra) - 1\n", "palindromo = True\n", "\n", "while i < j:\n", " if palavra[i] != palavra[j]:\n", " palindromo = False\n", " break\n", " i += 1\n", " j -= 1\n", "\n", "if palindromo:\n", " print(palavra, \"é um palíndromo\")\n", "else:\n", " print(palavra, \"não é um palíndromo\")\n", "```\n", "\n", "> 🆕 A função `len()` não foi mostrada até o momento, mas ela serve para lhe mostrar o comprimento (*length*) de uma palavra ou de uma lista de elementos. Por exemplo: `banana` tem 6 caracteres. Logo, `len('banana')` resultaria no valor `6`. Já `banana ` tem 7 caracteres (viu o espaço no final da palavra? Ele conta também). Então, `len('banana ')` resultaria em `7`.\n", "\n", "Primeiro, é solicitado ao usuário que digite uma palavra, e armazenamos isso na variável `palavra`. Depois disso, a variável `i` é iniciada em 0, e a variável `j` é iniciada com o comprimento da palavra menos 1, pois vamos usá-la para percorrer do final da palavra para a frente (ou seja: de trás para frente). Usamos a função `len()` para ver a quantidade de caracteres da palavra. A variável `palindromo` é iniciada como verdadeira, pois é o valor que será usado para testar no final se a palavra é ou não um palíndromo.\n", "\n", "O loop `while` verifica se os caracteres da palavra são iguais do começo ao final. Se os caracteres em posições diferentes não forem iguais, a variável `palindromo` é atribuída como falsa e o loop é interrompido com o `break`. Se o loop continuar até o final, a variável `palindromo` permanece verdadeira.\n", "\n", "Suponha que o usuário digite a palavra `soltas` como entrada. O código calculará o valor do primeiro e último caracteres da palavra e os comparará -- no caso, a letra `s` com a letra `s`. Como as letras são iguais, avançaremos para o próximo teste: agora, comparando a segunda letra com a penúltima. Agora, a comparação é a letra `o` com a letra `a`. Como elas são diferentes, já sabemos que esta palavra não é um palíndromo e, com isso, interrompemos a execução do loop.\n", "\n", "No fim, vemos o valor final da variável `palindromo`. Se ela for verdadeira, é impresso na tela que a palavra é um palíndromo, caso contrário é impresso que a palavra não é um palíndromo." ] }, { "cell_type": "markdown", "id": "67c56eb3-a5ea-4b5a-9f8f-adf4b3d70696", "metadata": {}, "source": [ "## Referências bibliográficas" ] }, { "cell_type": "markdown", "id": "e1aacf96-ae08-482a-9ba7-24bf0280151f", "metadata": {}, "source": [ "- COZINHA TÉCNICA. Brigadeiro de chocolate. Disponível em: https://www.cozinhatecnica.com/2014/10/brigadeiro/. Acesso em: 05 mar. 2023.\n", "- DOWNEY, Allen B. Think Python: How to Think Like a Computer Scientist. Green Tea Press, 2nd edition, 2012.\n", "- FORBELLONE, André Luiz Villar; EBERSPACHER, Henri Frederico L. Lógica de Programação: A Construção de Algoritmos e Estruturas de Dados. São Paulo: Pearson, 3ª edição, 2017.\n", "- PYTHON. Control Flow Tools: for statements. Disponível em: https://docs.python.org/3/tutorial/controlflow.html#for-statements. Acesso em: 05 mar. 2023.\n", "- PYTHON. Control Flow Tools: while statements. Disponível em: https://docs.python.org/3/tutorial/introduction.html#first-steps-towards-programming. Acesso em: 05\n", "- PYTHON. Control Flow Tools: for statements. Disponível em: https://docs.python.org/3/tutorial/controlflow.html#for-statements. Acesso em: 05 mar. 2023.\n", "- PYTHON. 4. More Control Flow Tools. Disponível em: https://docs.python.org/3/tutorial/controlflow.html#more-control-flow-tools. Acesso em: 06 mar. 2023.\n", "- PYTHON. 4.2. for Statements. Disponível em: https://docs.python.org/3/reference/compound_stmts.html#for. Acesso em: 06 mar. 2023.\n", "- W3SCHOOLS. Python for Loops. Disponível em: https://www.w3schools.com/python/python_for_loops.asp. Acesso em: 06 mar. 2023.\n", "- W3SCHOOLS. Python while Loops. Disponível em: https://www.w3schools.com/python/python_while_loops.asp. Acesso em: 06 mar. 2023.\n", "- ZIVIANI, Nivio. Projeto de Algoritmos com Implementações em Pascal e C. São Paulo: Cengage Learning, 2007." ] } ], "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.12" } }, "nbformat": 4, "nbformat_minor": 5 }