Comandos de Repetição

Até o momento aprendemos algumas notções básicas sobre programação. Entretanto, o que acontece se escrevermos algum código, mas quisermos repetir a tarefa várias vezes? Por exemplo, suponha que você tenha sido solicitado a escrever um programa que calcule a média aritmética de três notas das provas de uma turma com vários alunos. Embora não seja uma boa estratégia, uma abordagem seria escrever o código para calcular a média de um aluno e, em seguida, repetir esse código para cada aluno. Por exemplo, observe o seguinte:

# Obtém as notas do primeiro aluno
print("Aluno 1")
nota1 = float(input("Digite a Nota 1: "))
nota2 = float(input("Digite a Nota 2: "))
nota3 = float(input("Digite a Nota 3: "))
media = (nota1 + nota2 + nota3) / 3
print(f"Média do Aluno 1: {media:.2f}")

# Obtém as notas do segundo aluno
print("Aluno 2")
nota1 = float(input("Digite a Nota 1: "))
nota2 = float(input("Digite a Nota 2: "))
nota3 = float(input("Digite a Nota 3: "))
media = (nota1 + nota2 + nota3) / 3
print(f"Média do Aluno 2: {media:.2f}")

# Obtém as notas do tercerio aluno
print("Aluno 3")
nota1 = float(input("Digite a Nota 1: "))
nota2 = float(input("Digite a Nota 2: "))
nota3 = float(input("Digite a Nota 3: "))
media = (nota1 + nota2 + nota3) / 3
print(f"Média do Aluno 3: {media:.2f}")

# e assim por diante

Como você pode ver, esse código é uma estrutura de sequência longa que contém muito código duplicado. Existem várias desvantagens nesta abordagem, incluindo as seguintes:

O código duplicado torna o programa grande;
Escrever uma longa sequência de declarações pode consumir muito tempo;
Se parte do código duplicado tiver que ser corrigido ou alterado, então a correção ou a mudança tem que ser feita muitas vezes.

Em vez de escrever a mesma sequência de instruções repetidamente, a melhor maneira de executar uma operação repetidamente é escrever o código da operação uma vez e, em seguida, colocar esse código em uma estrutura que faça o computador repeti-lo quantas vezes forem necessárias. Isso pode ser feito com uma estrutura de repetição, mais comumente conhecida como loop.

Instrução `while`

A instrução while recebe esse nome pela maneira como funciona: enquanto uma condição for verdadeira, execute alguma tarefa. O loop tem duas partes: (\(i\)) uma condição que é testada para um valor verdadeiro ou falso e (\(ii\)) uma instrução ou conjunto de instruções que é repetida enquanto a condição for verdadeira. A figura abaixo mostra a lógica de um loop while.

O símbolo em formato de losango representa a condição a ser testada. Se a condição for verdadeira uma ou mais instruções são executadas e a execução do programa retorna ao ponto logo acima do símbolo do losango. Em seguida, a condição é testada novamente e, se for verdadeira, o processo se repete. Se a condição for falsa, o programa sai do loop. Em um fluxograma, você sempre reconhecerá um loop quando vir uma linha de fluxo voltando para uma parte anterior do fluxograma.

A sintaxe da instrução while em Python é mostrada abaixo:

Quando o while é executado, a condição é testada. Se a condição for verdadeira, as instruções que aparecem no bloco após a cláusula while serão executadas e o loop será reiniciado. Se a condição for falsa, o programa sai do loop. Veja um exemplo simples:

x = 1
while x <= 10:
    print(x)
    x += 1

Na linha 1 a variável x é inicializada com o valor 1. A linha 2 é uma combinação da estrutura condicional com estrutura de repetição. Podemos entender a condição do while da mesma forma que a condição de if. A diferença é que, se a condição for verdadeira, repetiremos as linhas 3 e 4 enquanto a avaliação da condição for verdadeira.

Dica

Abra o site PythonTutor e clique no botão Next > para visualizar a execução do código passo-a-passo.

O código abaixo mostra como podemos usar um loop while para escrever um programa que calcula a média aritmética de três notas das provas de uma turma com vários alunos:

#Variável para controlar o número de alunos
aluno = 0
#Variável para controlar o loop
continuar = 's'
while continuar == 's':
    aluno += 1
    print(f"Aluno {aluno}")
    nota1 = float(input("Digite a Nota 1: "))
    nota2 = float(input("Digite a Nota 2: "))
    nota3 = float(input("Digite a Nota 3: "))
    media = (nota1 + nota2 + nota3) / 3
    print(f"Média do Aluno {aluno}: {media:.2f}")

    continuar = input("Deseja ler as notas de mais um aluno (s ou n)?").lower()

Variáveis contadoras e acumuladoras

Em situações onde precisamos realizar contagens de ocorrências, ou somatórios/produtórios de valores dentro de um conjunto de dados, devemos utilizar variáveis específicas para fazer o armazenamento dos resultados. Chamamos de contadoras as variáveis que realizam a contagem de ocorrências de um determinado valor (ou evento/situação) e de acumuladoras as variáveis responsáveis por armazenar os resultados de somatórios e produtórios de valores.

Variáveis contadoras

As variáveis contadoras são normalmente inicializados com valor 0 e incrementados em 1 cada vez que uma nova ocorrência (ou evento) acontece. Por exemplo, considere que tenhamos um conjunto de dados com informações (idade e sexo) de 50 pessoas e desejemos saber quantas dessas pessoas são do sexo feminino e possuem 18 anos ou mais. Para isso, precisamos de um contador para armazenar a quantidade de ocorrências da condição definida no enunciado. Esse contador deve ser inicializado com 0 e incrementado em 1 sempre que o sexo de uma dada pessoa for feminino e sua idade for maior ou igual a 18.

Vamos a um exemplo, suponha que precisamos ler 10 número inteiros e contabilizar quantos desses número são pares. Nesse caso, podemos criar uma variável contaPar inicializada com 0 e, a cada leitura de dado, verificar se o valor lido é par ou não. Se for, incrementamos a variável contaPar em uma unidade, como mostra o código abaixo:

contaPar = 0
i = 0
while i < 10:
    x = int(input("Digite um número: "))
    if x % 2 == 0:
        contaPar += 1 # contaPar = contaPar +1
    i += 1
print(f"Foram digitados {contaPar} números pares")

Pergunta

Faz sentido contaPar começar com um valor diferente de zero? Qual deve ser a saída do programa se todos os números lidos forem impares?

Exercício

Modifique o código anterior para que o mesmo contabilize também a quantidade de números impares lidos.

Variáveis acumuladoras

Como mencionado anteriormente, as variáveis acumuladoras são utilizadas em dois tipos de situações, para a realização de somatórios e de produtórios. No caso dos somatórios, a variável é normalmente inicializada com o valor 0 e incrementado no valor de um outro termo qualquer, dependendo do problema em questão.

Considere que no problema anterior, além calcular a quantidade de números pares, também desejamos calcular a soma desses números. Nesse caso, precisamos inserir no código um acumulador, que deve ser inicializado em 0 e incrementado no valor do número lido. Note que, dessa forma, podemos facilmente calcular a média dos valores pares lidos. Veja o código abaixo:

contaPar = 0
somaPar = 0
i = 0
while i < 10:
    x = int(input("Digite um número: "))
    if x % 2 == 0:
        contaPar += 1 # contaPar = contaPar +1
        somaPar += x  # somaPar = somaPar + x
    i += 1
print(f"Foram digitados {contaPar} números pares")
print(f"Soma dos números pares: {somaPar}")  
if contaPar > 0:
    print(f"Média dos números pares: {somaPar/contaPar}")

Exercício

Modifique o código anterior para que o mesmo contabilize também a quantidade e a média dos números impares lidos.

No caso de utilizarmos variáveis acumuladoras para armazenar produtórios é necessário a inicialização da mesma com o valor neutro da multiplicação (o número 1). A cada iteração a variável é então multiplicado por um outro valor qualquer, dependendo do problema em questão.

Exercício

Modifique novamente o código anterior para que seja impresso também a multiplicação dos valores pares e impares lidos.

Instruções `break` e `continue`

Nos exemplos vistos até agora, todos os comandos do loop while são executados em cada iteração. Entretanto, existem duas palavras reservadas em Python que servem para auxiliar no controle do fluxo da estrutura de repetição. São elas: break e continue.

A instrução break é usada para sair do loop imediatamente. Geralmente utilizamos uma estrutura condicional com if para então usar a cláusula break.

# Finaliza o loop quando x se tornar 3
x = 6
while x:
    print(x)
    x -= 1
    if x == 3:
        break

O código abaixo faz a leitura de valores até que seja digitado o valor 0 (zero).

s = 0
while True:
    v = int(input("Digite um número a somar ou 0 para sair: "))
    if v == 0:
        break
    s = s + v
print(s)

A figura abaixo ilustra a lógica da instrução break.

A instrução continue ignora a iteração atual de um loop e continua com a próxima iteração. Exemplo:
```
# Ignora os números ímpares
x = 6
while x:
    x -= 1
    if x % 2 != 0:
        continue
    print(x)
```
A figura abaixo ilustra a lógica da instrução continue.

Fonte: Python while Loops

A distinção entre break e continue é demonstrada na imagem abaixo.

Repetições aninhadas

Em geral, as estruturas de controle do Python podem ser aninhadas umas nas outras, como vimos nas instruções condicionais if-elif-else. Da mesma forma, um loop while pode estar contido em outro loop while. Por exemplo, o código abaixo mostra uma forma de imprimir as tabuadas de multiplicação de 1 a 10.

tabuada = 1
while tabuada <= 10:
    numero = 1
    while numero <= 10:
        print(f"{tabuada} x {numero} = {tabuada * numero}")
        numero += 1
    tabuada += 1

Este código pode ser reimplementado sem utilizar repetições aninhadas:

tabuada = 1
numero = 1
while tabuada <= 10:
    print(f"{tabuada} x {numero} = {tabuada * numero}")
    numero += 1
    if numero == 11:
        numero = 1
        tabuada += 1

Além disso, os loops while podem ser aninhados dentro de instruções if-elif-else e vice-versa:

if <condicao>:
    <instrucao>
    while <condicao>:
        <instrucao>
        <instrucao>
else:
    while <condicao>:
        <instrucao>
        <instrucao>
    <instrucao>

while <condicao>:
    if <condicao>:
        <instrucao>
    elif <condicao>:
        <instrucao>
    else:
        <instrucao>

    if <condicao>:
        <instrucao>

Atenção

Uma instrução break ou continue em loops aninhados se aplica ao loop mais próximo:

while <condicao1>:
    <instrução>
    <instrução>

    while <condicao2>:
        <instrução>
        <instrução>
        break  # Aplica-se ao while <condicao2>

    break  # Aplica-se ao while <condicao1>

Material Complementar

Complemente sua leitura e seu conhecimento:

Comandos de Repetição

Instrução while

Variáveis contadoras e acumuladoras

Variáveis contadoras

Variáveis acumuladoras

Instruções break e continue

Repetições aninhadas

Material Complementar

Instrução `while`

Instruções `break` e `continue`