T05 2025-1 (3)

Prévia do material em texto

Universidade Federal de Ouro Preto - UFOP
Instituto de Ciências Exatas e Biológicas - ICEB
Departamento de Computação - DECOM
Programação de Computadores I
BCC 701
Aula Teórica
while
Prof. Marcelo Luiz Silva (Red)
red@ufop.edu.br
Programação Estruturada
É uma técnica de programação de computadores que 
utiliza três estruturas básicas para descrição do fluxo de 
execução de um programa:
• Sequência
• Decisão (desvio, condição)
• Iteração (repetição)
Conceitos de Programação
Motivação: capturar os zumbis ! Início zero capturados.
capturado = 0
Enquanto houver zumbis:
Acerte 1 zumbi
Retire o zumbi
# conte o zumbi
capturado = capturado + 1
print(f ’Capturados = {capturado}’)
Execução:
Capturados = 3
Há zumbi ? capturado
Início 0
True
True
True
1 = 0 + 1
Iteração - Repetição - Laço
False
2 = 0 + 1 + 1
3 = 0 + 1 + 1 + 1
Sai do laço
Iteração - Repetição - Laço
• Para permitir que uma operação seja executada repetidas vezes 
utilizam-se os comandos de repetição.
• Uma estrutura deste tipo também é chamada de laço (do inglês loop).
• Laço controlado logicamente (comando while).
• Em um laço controlado logicamente, os comandos (corpo do laço) são 
repetidos enquanto uma expressão lógica for verdadeira.
• Iteração é cada execução do corpo do laço (cada repetição do 
conjunto de comandos), juntamente com a condição de terminação do 
laço.
Problema
Codificar um programa para imprimir os 4 primeiros números naturais:
N = { 0, 1, 2, 3 }
nat = 0
print(f"x1 = {nat} ")
nat +=1
print(f"x1 = {nat} ")
nat +=1
print(f"x1 = {nat} ")
nat +=1
print(f"x1 = {nat} ")
Saída na tela:
0 1 2 3
Iteração - Repetição - Laço
• Observa-se uma sequência de 
comandos repetidos.
• Os comandos são praticamente 
idênticos, geralmente, ocorrendo 
mudanças nos valores armazenados 
nas variáveis (endereços de 
memória).
Fluxograma
Iteração - Repetição - Laço
Início
Fim
nat = 0
nat
nat +=1
Na 
Programação 
Sequencial, 
o fluxo de 
execução
de um 
programa 
ocorre na 
execução de 
um comando 
após o outro.
nat
nat +=1
nat +=1
nat
nat
Problema
Codificar um programa para imprimir os 1000 primeiros números 
naturais:
N = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ..., 999 }
nat = 0
print(f"x1 = {nat} ")
nat +=1
print(f"x1 = {nat} ")
nat +=1
print(f"x1 = {nat} ")
nat +=1
print(f"x1 = {nat} ")
• • •
nat +=1
print(f"x1 = {nat} ")
Iteração - Repetição - Laço
Os comandos de atribuição e 
print são repetidos
1000
vezes !
Solução: comandos de 
repetição
Soma Acumulada
Antes de propormos uma solução para a impressão dos números naturais, vamos 
entender o conceito de soma acumulada.
A soma acumulada atualiza o valor corrente (atual) de uma variável por um novo 
valor calculado. Exemplo: R A M
soma = 0 # 1
soma = soma + 4 # 2
soma += 2 # 3
soma += 8 # 4
soma += 12 # 5
Iteração - Repetição - Laço
Passo de 
Execução
Valor Armazenado 
em soma
Observação
1 0 Atribuição inicial
2 4 Acumulou 4 unidades
3 6 Acumulou 2 unidades
4 14 Acumulou 8 unidades
5 26 Acumulou 12 unidades
Definição Sintática do Comando while
• A estrutura de controle while é utilizada para se repetir a execução de um bloco de 
comandos, enquanto uma determinada condição for verdadeira (resultar em True).
• Em sua sintaxe, é uma expressão lógica que resulta True ou False; e 
representa as linhas de comandos que serão executados se a condição for True:
while :
...
... # último comando
• Após a execução do último comando, ocorre o laço para a condição do while (volta para a 
condição). Repete-se o processo: se a condição é verdadeira, repete-se o bloco; se falsa, a 
execução do programa passa para o primeiro comando após o while.
Iteração - Repetição - Laço
Indentação 4 
brancos de 
recuo
Definição de Contador
• Contador é uma variável que controla o número de iterações (repetições). 
• O contador recebe um valor inicial antes do laço e este valor é utilizado na expressão lógica.
• No bloco de comandos, o contador deve ser atualizado de alguma forma; geralmente a 
atualização é o último comando do bloco.
• A atualização pode ser a leitura de um novo valor, um incremento (somar uma constante) ou 
decremento (subtrair uma constante).
contador = 10
while contador >= 1:
...
...
contador -= 1 # último comando
Iteração - Repetição - Laço
Fluxograma
Iteração - Repetição - Laço
Início
Fim
nat = 0
n = 1000
nat +=1
nat
nat 2}: {nat:>2}")
contador += 1
nat += 1
print(f"O laço terminou com {n} iterações !")
Iteração - Repetição - Laço
O corpo do laço contém os comandos que representam cada iteração.
Saída na Tela:
Natural 1: 0
Natural 2: 1
Natural 3: 2
Natural 4: 3
Natural 5: 4
Natural 6: 5
Natural 7: 6
Natural 8: 7
Natural 9: 8
Natural 10: 9
Natural 11: 10
Natural 12: 11
Natural 13: 12
Natural 14: 13
Natural 15: 14
Natural 16: 15
Natural 17: 16
Natural 18: 17
Natural 19: 18
Natural 20: 19
O laço terminou
Com 20 iterações
Calculado o Somatório de Séries Matemáticas
Considera a séria abaixo:
(1)
• Utilizando-se o processo de somas acumuladas, somando cada parcela, uma de 
cada vez, podemos calcular o somatório com programa simples.
• Com relação a primeira parcela 1/1, a somaremos com a variável que acumula a 
soma, por exemplo S. Inicialmente S tem o valor zero.
• Um contador de parcelas é utilizado para indicar qual parcela deve ser somada 
(acumulada). Desta forma, quando o contador for 1, soma-se a primeira parcela; 
quando o contador for 2, soma-se a segunda parcela; quando o contador for 3, 
soma-se a terceira parcela; e assim sucessivamente.
• Cada parcela é definida por uma fração na forma: numerador / denominador.
• Para os cálculos deve-se encontrar uma relação matemática entre o numerador e o 
denominador de cada parcela. 
• Sendo n uma variável para o numerador, então o respectivo denominador será
2 * n – 1.
Iteração - Repetição - Laço
𝑺 =
𝟏
𝟏
+
𝟐
𝟑
+
𝟑
𝟓
+
𝟒
𝟕
+
𝟓
𝟗
+ ⋯ +
𝟓𝟎
𝟗𝟗
Calculado o Somatório de Séries Matemáticas
Iteração - Repetição - Laço
Soma p1
1/1
𝑺 =
𝑺 =
𝟏
𝟏
+
𝟐
𝟑
+
𝟑
𝟓
+
𝟒
𝟕
+
𝟓
𝟗
+ ⋯ +
𝟓𝟎
𝟗𝟗
𝟎 +
𝟏
𝟏
+
𝟐
𝟑
+
𝟑
𝟓
+
𝟒
𝟕
+
𝟓
𝟗
Parcela num
den
2*num-1
Início: S = 0
Soma Acumulada
S = S + num / den
1 1 1 0 + 1/1
2 2 3 0 + 1/1 + 2/3
3 3 5 0 + 1/1 + 2/3 + 3/5
4 4 7 0 + 1/1 + 2/3 + 3/5 + 4/7
5 5 9 0 + 1/1 + 2/3 + 3/5 + 4/7 + 5/9
Soma p2
2/3
Soma p3
3/5
Soma p4
4/7
Soma p5
5/9
Código Série 1
num = 1
s = 0
while (num𝟏𝟗
+ ⋯ +
𝟓𝟎
𝟗𝟗
Calculado o Somatório de Séries Matemáticas
(2)
Iteração - Repetição - Laço
Soma p1
2/3
𝑺 =
𝑺 =
𝟐
𝟑
+
𝟒
𝟕
+
𝟔
𝟏𝟏
+
𝟖
𝟏𝟓
+
𝟏𝟎
𝟏𝟗
+ ⋯ +
𝟓𝟎
𝟗𝟗
𝟎 +
𝟐
𝟑
+
𝟒
𝟕
+
𝟔
𝟏𝟏
+
𝟖
𝟏𝟓
+
𝟏𝟎
𝟏𝟗
Parcela num
den
2*num- 1
Início: S = 0
Soma Acumulada
S = S + num / den
1 2 3 0 + 2/3
2 4 7 0 + 1/1 + 4/7
3 6 22 0 + 1/1 + 2/3 + 6/11
4 8 15 0 + 1/1 + 2/3 + 3/5 + 8/15
5 10 19
0 + 1/1 + 2/3 + 3/5 + 4/7 + 
10/19
Soma p2
4/7
Soma p3
6/11
Soma p4
8/15
Soma p5
10/19
Código Série 2 – versão 1
n = 0
s = 0
num = 1 
while (num = 0):
if ((nro % 2) == 0): # se True, é par
soma += nro # acumula nro na soma
qtd += 1 # conta o número acumulado
nro = int(input("Digite um número natural: "))
mediaPar = soma / qtd
print(f"\nMédia dos Pares: {mediaPar:8.3f}")
print(f"Quantidade de Pares: {qtd}")
print("Fim do Programa !")
Iteração - Repetição - Laço
Exemplo de Execução
Iteração - Repetição - Laço
Cálculo da Média dos Pares
Digite um número natural: 2
Digite um número natural: 6
Digite um número natural: 7
Digite um número natural: 9
Digite um número natural: 1
Digite um número natural: 0
Digite um número natural: 8
Digite um número natural: 2
Digite um número natural: 33
Digite um número natural: 11
Digite um número natural: 77
Digite um número natural: 8
Digite um número natural: 22
Digite um número natural: -8
Média dos Pares: 6.857
Quantidade de Pares: 7
Fim do Programa !
Código
print(f"Cálculo da Média dos Pares")
qtd = 0 # quantidade de pares inicial
soma = 0 # soma de pares inicial
nro = int(input("Digite um número natural: "))
while (nro >= 0):
if ((nro % 2) == 0): # se True, é par
soma += nro # acumula nro na soma
qtd += 1 # conta o número acumulado
nro = int(input("Digite um número natural: "))
mediaPar = soma / qtd
print(f"\nMédia dos Pares: {mediaPar:8.3f}")
print(f"Quantidade de Pares: {qtd}")
print("Fim do Programa !")
O que aconteceria se o primeiro número digitado fosse negativo ?
O que aconteceria se todos os números digitados possem ímpares ?
Iteração - Repetição - Laço
Código e Exemplo de Execução
print(f"Cálculo da Média dos Pares")
qtd = 0 # quantidade de pares inicial
soma = 0 # soma de pares inicial
nro = int(input("Digite um número natural: "))
while (nro >= 0):
if ((nro % 2) == 0): # se True, é par
soma += nro # acumula nro na soma
qtd += 1 # conta o número acumulado
nro = int(input("Digite um número natural: "))
if (qtd == 0):
print(f"Erro de divisão por zero !")
else:
mediaPar = soma / qtd
print(f"\nMédia dos Pares: {mediaPar:8.3f}")
print(f"Quantidade de Pares: {qtd}")
print("Fim do Programa !")
Iteração - Repetição - Laço
Exemplo de Execução
Iteração - Repetição - Laço
Cálculo da Média dos Pares
Digite um número natural: 2
Digite um número natural: 6
Digite um número natural: 7
Digite um número natural: 9
Digite um número natural: 1
Digite um número natural: 0
Digite um número natural: 8
Digite um número natural: 2
Digite um número natural: 33
Digite um número natural: 11
Digite um número natural: 77
Digite um número natural: 8
Digite um número natural: 22
Digite um número natural: -8
Média dos Pares: 6.857
Quantidade de Pares: 7
Fim do Programa !
Situtações que Requerem o Uso do Comando while
• Utiliza-se o comando while quando não se conhece previamente o número de 
iterações, ou repetições, do laço. Apesar deste fato, sabe-se que um evento 
permitirá que o programa saia do laço e termine normalmente.
• Também, pode-se usar o while quando se conhece o número de iterações. Neste 
caso, teremos a inicialização do contador de iterações fora do laço, seguido do teste 
para entrada no laço, e geralmente, o último comando é a atualização do contador 
antes de se retornar ao teste do laço:
Iteração - Repetição - Laço
limite = 20 # número de iteraçoes
•••
cont = 1 # primeira contagem
•••
while (cont 
Cálculo do Máximo Divisor Comum - MDC
Iteração - Repetição - Laço
print(f"Cálculo do MDC - Algoritmo de 
Euclides")
x = int(input(‘Primeiro inteiro: ’))
x1 = x # salvo o valor de x
y = int(input(‘Segundo inteiro: ’))
y1 = y # salvo o valor de y
print(f"| x | y | resto |")
print(f"|{x:^7d}|{y:^7d}|", end="")
while (y != 0):
resto = x % y
print(f"{resto:^7d}|")
print(f"| | | |")
x = y
y = resto
print(f"|{x:^7d}|{y:^7d}|", end="")
print(f"\n\nMDC({x1}, {y1}) = {x}")
Cálculo do MDC
Algoritmo de Euclides
Primeiro inteiro: 448
Segundo inteiro: 21468
| x | y | resto |
| 448 | 21468 | 448 |
| | | |
| 21468 | 448 | 412 |
| | | |
| 448 | 412 | 36 |
| | | |
| 412 | 36 | 16 |
| | | |
| 36 | 16 | 4 |
| | | |
| 16 | 4 | 0 |
| | | |
| 4 | 0 |
MDC(448, 21468) = 4
Cálculo do Máximo Divisor Comum - MDC
Iteração - Repetição - Laço
x = int(input("Primeiro inteiro: "))
y = int(input("Primeiro inteiro: "))
while (y != 0):
resto = x % y
x = y
y = resto
x y resto y != 0
448
448
21468
412
36
16
4
21468
448
412
36
16
4
0
448
412
36
16
4
0True
True
True
True
True
True
False MDC(448, 21468) = 4
Condição False, logo y == 0
Sai do laço !
MDC está armazenado em x
Validação de Dados de Entrada - Testando Um Valor Inteiro e positivo
print(f"Loop para validar a entrada do usuário. ")
print(f"Ao sair do laço: o valor é inteiro e positivo !")
x = input("Digite um valor inteiro e positivo: ")
while (x.isdigit() == False):
print(f"ERRO: {x} não é inteiro e positivo !")
x = input(" Digite um valor inteiro e positivo: ")
# saindo do laço,
# converte-se a string para um inteiro
x = int(x)
print(f"\nAgora o programa continua, 
tenho a certeza que:")
print(f"O valor da entrada é inteiro: {x}")
Observações:
• Não se pode prever quantas vezes o usuário entrará com um
valor incorreto (não inteiro).
• Não se conhece o número de iterações (repetições).
Iteração - Repetição - Laço
Loop para validar a entrada do usuário.
Ao sair do laço: o valor é inteiro e 
positivo !
Digite um valor inteiro e positivo: -6
ERRO: -6 não é inteiro e positivo !
Digite um valor inteiro e positivo: 3.8
ERRO: 3.8 não é inteiro e positivo !
Digite um valor inteiro e positivo: 4
Agora o programa continua, tenho a 
certeza que:
O valor da entrada é inteiro: 4
Cuidados com o contador do while
Fique atento a inicialização do contador antes do laço e a sua atualização, geralmente, 
no último comando do laço.
Iteração - Repetição - Laço
x = 0
while (x = 50):
valorCompra -= 50
N50 += 1
while (valorCompra >= 10):
valorCompra -= 10
N10 += 1
print(f"Moedas para pagamento:")
if (N50 > 0):
print(f"{N50} moeda(as) de 50")
if (N10 > 0):
print(f"{N10} moeda(as) de 10")
if (valorCompra > 0):
print(f"{int(valorCompra)} moeda(as) de 1")
Iteração - Repetição - Laço
Valor da compra: R$ 174.00
Moedas para pagamento:
3 moeda(as) de 50
2 moeda(as) de 10
4 moeda(as) de 1
Valor da compra: R$ 505.00
Moedas para pagamento:
10 moeda(as) de 50
5 moeda(as) de 1
Valor da compra: R$ 620.00
Moedas para pagamento:
12 moeda(as) de 50
2 moeda(as)de 10
Exercício 7
Um determinado material radioativo perde 1% de sua massa a 
cada 50 segundos.
Codifique um programa que leia uma massa inicial em gramas 
desse material. A massa fornecida deve ser maior que 0,5 gramas. 
Caso não seja satisfeita esta condição, o programa repete a entrada 
até que uma massa com esta especificação seja fornecida.
O programa calcula e imprime o tempo necessário para que a 
massa se torne menor que 0,5 gramas.
As entradas e saídas seguem o modelo de execução.
Iteração - Repetição - Laço
Exercício 7
massaInicial = float(input("Digite a massa (g): "))
while (massaInicial = 0.5:
massaFinal *= 0.99 # perdeu 1%
nroPerda += 1
tempo = nroPerda * 50
segundos = tempo % 60
minutos = ( int(tempo / 60) ) % 60
horas = int(tempo / 3600)
print(f"Resultados:")
print(f"Massa inicial: {massaInicial:>10.6f}")
print(f"Massa final: {massaFinal:>10.6f}")
print(f"Tempo gasto (h:m:s) = {horas}:{minutos}:{segundos}")
Iteração - Repetição - Laço
Exercício 7
Exemplo de Execução
Digite a massa (g): 0.49
ERRO: massa = 0.0001 ):
xAnterior = x
x = (x*x + y) / (2*x)
print(f"Raiz quadrada de {x:5.2f} = {y:5.2f}")
Exemplo de Execução
Digite o valor de y: 81
Raiz quadrada de 9.00 = 81.00
Iteração - Repetição - Laço
Boa prática de estudos:
• Digite todos os programas desta aula em seu
computador.
• Observe e analise os resultados.
• Acostume-se com as indentações.
• Pratique com exercícios extras, indicados pelo
professor, para memorizar os conceitos da aula.
• Bons estudos !
Identifique as repetições...
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22
	Slide 23
	Slide 24
	Slide 25
	Slide 26
	Slide 27
	Slide 28
	Slide 29
	Slide 30
	Slide 31
	Slide 32
	Slide 33
	Slide 34
	Slide 35
	Slide 36
	Slide 37
	Slide 38
	Slide 39
	Slide 40
	Slide 41
	Slide 42
	Slide 43
	Slide 44
	Slide 45
	Slide 46
	Slide 47
	Slide 48
	Slide 49