Repetições, repetições, repetições: loops em Python#

O que você saberá se você ler todo este capítulo?#

  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.

  2. Saberá que existem dois principais tipos de loops: “para” (for) e “enquanto” (while).

  3. Também entenderá que geralmente usamos o for quando sabemos exatamente quantas vezes queremos executar uma ação.

  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).

  5. Que é possível combinar if com loops.

  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).

Explicando loops com bolos e brigadeiros#

Lembra quando introduzimos o conceito de algoritmos com uma receita de bolo? Vamos agora pensar em uma receita de brigadeiros. O que acha?

Imagem contendo vários doces do tipo brigadeiro.
Brigadeiros. Servido? Créditos: Mayra Chiachia, no Flickr.

Ingredientes#

  • 1 lata de leite condensado

  • 2 colheres (sopa) de cacau em pó

  • 1 colher (sopa) de manteiga sem sal

  • Granulado de chocolate para cobrir

Modo de preparo#

  1. Em uma panela, adicione o leite condensado, o cacau em pó e a manteiga sem sal.

  2. Leve a panela ao fogo baixo e mexa sem parar até que a mistura comece a soltar do fundo da panela.

  3. Desligue o fogo e continue mexendo a mistura até que ela esfrie um pouco.

  4. Coloque o granulado em um prato.

  5. Enquanto ainda tiver mistura sobrando, faça:

  6. Pegue uma pequena porção da mistura e faça uma bolinha do tamanho de uma cereja.

  7. Passe a bolinha de brigadeiro no granulado, cobrindo-a completamente.

  8. Coloque a bolinha em uma forma.

  9. No final, coloque as bolinhas em forminhas de papel ou em um prato para servir.

Resultado esperado#

Brigadeiros cobertos com granulado de chocolate.

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.

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.

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:

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.

Um exemplo em Python#

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ó:

print(1)
print(2)
print(3)
print(4)
print(5)
print(6)
print(7)
print(8)
print(9)
print(10)

E se eu pedisse a você para mudar este código para mostrar todos os números de 1 a 1000? Aí complica, né?

Repetições com for (“para”) e while (“enquanto”)#

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.

Vamos imaginar um cenário em que precisamos caminhar por um trajeto pré-determinado ou explorar uma área desconhecida.

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.

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.

📝 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.

Veja como seria o uso do “para” em pseudocódigo para escrever todos os números de 1 a 1000 na tela:

1. Início
2.   Inteiro: i
3.
4.   Para todo i de 1 até 1000, faça:
5.     Escreva(i)
6.   Fim Para
7. Fim

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.

Agora, veja o uso do “enquanto” para resolver o mesmo problema:

1. Início
2.   Inteiro: i
3.
4.   i = 1
5.   Enquanto i <= 1000, faça:
6.     Escreva(i)
7.     i = i + 1
8.   Fim Enquanto
9. Fim

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.

for#

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:

for i in range(1, 1001):
    print(i)

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:”.

🔄 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).

Exemplos#

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á?

Soma de 1 a 10#

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:

soma = 0
for num in range(1, 11):
    soma += num
print("A soma dos números é:", soma)

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.

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.

Soma de 10 a 50#

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:

numeros = [10, 25, 1, 40, -4]
soma = 0
for num in numeros:
    soma += num
print("A soma dos números é:", soma)

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.

🐱‍🏍 Fique tranquilo! Um pouco depois deste capítulo iremos nos aprofundar em listas.

Em seguida, é criada uma variável chamada soma com valor inicial igual a 0.

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.

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.

Quadrado#

Agora, e se fôssemos calcular o quadrado de cada número de uma sequência? Veja só:

numeros = [1, 2, 3, 4, 5]
for num in numeros:
    quadrado = num ** 2
    print(quadrado)

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.

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.

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.

Percorrendo strings#

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:

nome = input("Digite o seu nome: ")

for letra in nome:
    print(letra)

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.

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.

Por exemplo, se o usuário digitar “Maria”, o resultado mostrado na tela será:

M
a
r
i
a

Percorrendo listas de palavras#

E se quiséssemos percorrer uma lista de palavras e verificar se alguma delas contém a letra r? Olha só:

for palavra in ["casa", "amor", "árvore", "abacaxi"]:
    if 'r' in palavra:
        print(palavra)

A estrutura for palavra in ["casa", "amor", "arvore", "abacaxi"]: indica que o loop irá percorrer cada palavra da lista ["casa", "amor", "arvore", "abacaxi"].

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".

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".

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.

Filtrando números pares#

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ó:

for num in range(1, 21):
    if num % 2 == 0:
        print(num, " é um número par")

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.

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.

Por fim, a linha print(num, " é um número par") imprime o número par encontrado.

while#

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:

i = 1
while i <= 1000:
    print(i)
    i += 1

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.

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.

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.

Soma de 1 a 10#

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:

i = 1
soma = 0
while i <= 10:
    soma += i
    print(soma)
    
    i += 1

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.

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:

  1. Primeiro passo: soma (0) + i (1) = 1, que passará a ser o novo valor de soma.

  2. Segundo passo: soma (1) + i (2) = 3, que passará a ser o novo valor de soma.

  3. Terceiro passo: soma (3) + i (3) = 6, que passará a ser o novo valor de soma.

  4. Quarto passo: soma (6) + i (4) = 10, que passará a ser o novo valor de soma.

  5. Quinto passo: soma (10) + i (5) = 15, que passará a ser o novo valor de soma.

  6. Sexto passo: soma (15) + i (6) = 21, que passará a ser o novo valor de soma.

  7. Sétimo passo: soma (21) + i (7) = 28, que passará a ser o novo valor de soma.

  8. Oitavo passo: soma (28) + i (8) = 36, que passará a ser o novo valor de soma.

  9. Nono passo: soma (36) + i (9) = 45, que passará a ser o novo valor de soma.

  10. Décimo passo: soma (45) + i (10) = 55, que passará a ser o novo valor de soma.

Testando uma senha#

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:

senha = ""
while senha != "12345":
    senha = input("Digite a senha: ")
print("Acesso permitido!")

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.

Fazendo um menu#

E o que acha de fazer um menu bonitão para o usuário? Com o while, isto é possível. Veja:

opcao = ''
while opcao != 's':
    print("MENU:")
    print("a. Opção 1")
    print("b. Opção 2")
    print("c. Opção 3")
    print("s. Sair")
    opcao = input("Digite uma opção: ")
    if opcao == 'a':
        print("Opção 1 selecionada")
    elif opcao == 'b':
        print("Opção 2 selecionada")
    elif opcao == 'c':
        print("Opção 3 selecionada")
    elif opcao == 's':
        print("Saindo...")
    else:
        print("Opção inválida.")

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.

👉 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ê.

Testando números positivos e negativos#

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:

num = int(input("Digite um número (digite 0 para sair): "))
while num != 0:
    if num > 0:
        print("O número é positivo")
    else:
        print("O número é negativo")
    num = int(input("Digite outro número (digite 0 para sair): "))

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.

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.

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.

Inserindo notas válidas#

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:

nota = -1
while nota < 0 or nota > 10:
    nota = float(input("Digite uma nota entre 0 e 10: "))
print("Nota válida:", nota)

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).

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.

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.

Exercícios#

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?

  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.

    • 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.

  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.

    • Exemplo: um usuário digita o número 53. O algoritmo deve retornar a mensagem “53 é um número primo”.

  3. Crie um algoritmo que mostra todos números de 5 a -5 usando o for.

    • 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.

  4. Crie um algoritmo para calcular o fatorial de um número usando o for.

    • Exemplo: um usuário digita 5. O algoritmo deve retornar 120 (\(5! = 5 * 4 * 3 * 2 * 1 = 120\)).

  5. Escreva um algoritmo para verificar se uma palavra é um palíndromo usando o while.

    • Exemplo: radar é um palíndromo (se ler a palavra de trás para frente resultará na mesma palavra). banana não é um palíndromo.

Respostas#

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.

inicio = int(input("Insira um número para começar a contagem: "))
fim = int(input("Insira um número para terminar a contagem: "))

for num in range(inicio, fim+1):
    if num % 2 == 0:
        print(num, "é um número par")

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.

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.

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.

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”.

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.

num = int(input("Digite um número: "))
primo = True

for i in range(2, num):
    if num % i == 0:
        primo = False
        break

if primo:
    print(num, "é um número primo")
else:
    print(num, "não é um número primo")

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.

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.

👉 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.

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.

3. Crie um algoritmo que mostra todos números de 5 a -5 usando o for.

for i in range(5, -6, -1):
    print(i)

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:

  • Primeiro argumento: o valor inicial (5).

  • Segundo argumento: o valor final (-6).

  • Terceiro argumento: como devemos percorrer do valor inicial para o final (no caso, avançando de -1 em -1).

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.

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.

4. Crie um algoritmo para calcular o fatorial de um número usando o for.

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:

num = int(input("Digite um número: "))

fatorial = 1
for i in range(1, num+1):
    fatorial *= i

print("O fatorial de", num, "é", fatorial)

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.

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.

Por fim, o programa exibe na tela o resultado da operação, informando o número digitado e o seu fatorial correspondente.

5. Escreva um algoritmo para verificar se uma palavra é um palíndromo usando o while.

Sei que este aqui é bem mais difícil e complexo. Na verdade, a ideia é muito mais a de compartilhar funcionalidades novas. Teste isto:

palavra = input("Digite uma palavra: ")
i = 0
j = len(palavra) - 1
palindromo = True

while i < j:
    if palavra[i] != palavra[j]:
        palindromo = False
        break
    i += 1
    j -= 1

if palindromo:
    print(palavra, "é um palíndromo")
else:
    print(palavra, "não é um palíndromo")

🆕 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.

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.

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.

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.

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.

Referências bibliográficas#