Aula09_EstruturasCondicionais(Python)_Leandro

Prévia do material em texto

IEC037
Introdução à Programação de Computadores
Aula 09 – Estruturas Condicionais em Python
Turma: 03
Professor: Leandro Galvão
E‐mail: galvao@icomp.ufam.edu.br
Página: ipc‐t03.weebly.com
Resolução de Problemas Algorítmicos
Definir as entradas e as 
saídas
Fim
Identificar o problema
Início
Converter o algoritmo em 
declarações da linguagem de 
programação
Projetar o algoritmo
Decompor
Refinar
passo a passo
Testar o programa 
resultante
1
2
3
4
5
Conteúdo
Estruturas Condicionais Simples
Estruturas Condicionais Compostas
Como montar uma condição?
Estruturas Condicionais Encadeadas
Estruturas de Programação
 Qualquer programa de computador pode ser 
escrito combinando‐se os três tipos básicos de 
estruturas de programação:
Sequencial Condicional Repetição
Estruturas de Programação
 Teorema provado em 
1966 por Corrado
Böhm (1923‐) e 
Giuseppe Jacopini
(1936‐2001) no artigo: 
“Flow Diagrams, 
Turing Machines And 
Languages With Only 
Two Formation Rules”.
Estrutura Sequencial
 É a estrutura de programação mais simples.
 O fluxo de comandos do algoritmo segue a mesma 
sequência linear da nossa escrita:
 De cima para baixo
 Da esquerda para direita
p/ esquerda
p/ baixo a = 3b = 4
m = (a + b)/2
print(m)
Estrutura Condicional
 Permite alterar o fluxo de execução, de forma a 
selecionar qual parte do algoritmo deve ser 
executada.
 Essa decisão é tomada a partir de uma condição, 
que pode resultar apenas em:
 Verdade, ou
 Falsidade
?
Condição verdadeira, condição falsa
 Verdadeiro ou falso são valores lógicos. São 
atributos da expressão condicional.
 O funcionamento correto do seu script não está 
condicionado a resultados lógicos com valor 
verdadeiro.
quebrou?
Estrutura Condicional Simples
 Quando a condição é 
verdadeira, o “bloco 
verdade” é executado.
 Quando a condição é 
falsa, o “bloco 
verdade” não é 
executado.
if (delta < 0):
print('Nao tem raizes reais')
if (delta < 0):
print('Nao tem raizes reais')
início
a, b, c
fim
delta < 0
F Não tem 
raízes reais
V
delta ← b**2 – 4*a*c
Estrutura Condicional Simples
:: Em Python
a = float(input("Digite a: "))
b = float(input("Digite b: "))
c = float(input("Digite c: "))
a = float(input("Digite a: "))
b = float(input("Digite b: "))
c = float(input("Digite c: "))
início
a, b, c
fim
delta < 0
F Não tem 
raízes reais
v
delta ← b**2 – 4*a*c
if (delta < 0):
print("Nao tem raizes reais")
if (delta < 0):
print("Nao tem raizes reais")
delta = b**2 – 4 * a * cdelta = b**2 – 4 * a * c
Condições sempre terminam 
com sinal de dois pontos
Comandos internos às condições 
devem ser recuados (tecla TAB)
Exemplo A
# Script que calcula o valor do ingresso
# a depender de se houver meia entrada
op = input("Meia entrada? (S/N) ")
ingresso = 30
if (op == "S"):
ingresso = ingresso/2
print("Valor do ingresso: ", ingresso)
Recuo do comandos dependente 
da condição (tecla TAB)
001
Conteúdo
Estruturas Condicionais Simples
Estruturas Condicionais Compostas
Como montar uma condição?
Estruturas Condicionais Encadeadas
Estruturas Condicionais Compostas
 Quando a condição é 
verdadeira, o “bloco 
verdade” é executado.
 Quando a condição é 
falsa, o “bloco 
falsidade” é executado.
if (delta < 0):
print("Nao tem raiz real")
else:
print("Tem raiz real")
if (delta < 0):
print("Nao tem raiz real")
else:
print("Tem raiz real")
início
a, b, c
fim
delta < 0
F
Não tem 
raízes reais
V
delta ← b**2 – 4*a*c
Tem raiz 
real
Estruturas Condicionais Compostas
:: Em Python
if (delta < 0):
print("Nao tem raiz real")
else:
print("Tem raiz real")
if (delta < 0):
print("Nao tem raiz real")
else:
print("Tem raiz real")
if e else sempre terminam 
com sinal de dois pontos
Comandos internos ao if e 
ao else devem ser recuados
início
a, b, c
fim
delta < 0
F
Não tem 
raízes reais
V
delta ← b**2 – 4*a*c
Tem raiz 
real
a = float(input("Digite a: "))
b = float(input("Digite b: "))
c = float(input("Digite c: "))
a = float(input("Digite a: "))
b = float(input("Digite b: "))
c = float(input("Digite c: "))
delta = b**2 – 4 * a * cdelta = b**2 – 4 * a * c
Exemplo B
# Script que verifica se o aluno passou 
ou nao com base na media
m = float(input("Digite sua media: "))
if (m >= 5.0):
print("Passou")
else:
print("Reprovou")
if e else sempre terminam 
com sinal de dois pontos
Comandos internos ao if e 
ao else devem ser recuados
002
Indentação
 O comando else deve estar alinhado com o 
comandos if correspondente.
 Todos os comandos de um mesmo bloco deverão 
ter o mesmo recuo.
Indentação
:: Cuidados
Indentação Válida Indentação Inválida
if (condição):
comando
comando
else:
comando
comando
if (condição):
comando
comando
else:
comando
comando
if (condição):
comando
comando
else:
comando
comando
Indentação
:: Diferenças
if (temp > 25):
print("Quente")
print("Ligue o ventilador")
print("Tchau")
if (temp > 25):
print("Quente")
print("Ligue o ventilador")
print("Tchau")
F
Vt > 25
Tchau
Quente
Ligue o ...
003
F
Vt > 25
Tchau
Quente
Ligue o ...
Não confunda
Indentação (identação)
• Inserção de espaços em um código 
de linguagem de programação
Endentação
• Encaixe dos dentes de uma peça 
denteada com os de outra
Problema 1
 Uma lata de leite em pó da marca A, com 400g, 
custa R$ 8,39.
 Um saco de leite em pó da marca B, com 1kg, custa 
R$ 20,30.
 Qual marca tem o melhor preço?
Problema 1
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas
PrecoA R$ 8.39
PesoA kg 0.4
PrecoB R$ 20.30
PesoB kg 1.0
Saídas Marca ‐‐‐ {“A”, “B”}
Problema 1
3 – Projetar algoritmo
F
V
início
PrecoA, PesoA
PrecoB, PesoB
fim
marca ← “A”
rA > rB
marca ← “B”
rA← PrecoA/PesoA
rB← PrecoB/PesoB
marca
Problema 1
4 – Codificar em Python
# Entrada de dados
pA = float(input("Digite o preco da marca A: "))
pB = float(input("Digite o preco da marca B: "))
mA = float(input("Digite o peso da marca A: "))
mB = float(input("Digite o peso da marca B: "))
rA = pA / mA
rB = pB / mB
if (rA > rB):
marca = "B"
else:
marca = "A"
print("Compre a marca ", marca)
Recuo do comandos dependente 
da condição (tecla TAB) 004
Problema 2
 Um radar de trânsito 
verifica a velocidade 
dos veículos.
 Caso ultrapassem 60 
km/h, emite‐se um 
registro de multa.
 O valor da multa é de 
R$ 200,00 mais R$ 3,00 
para cada 1 km/h acima 
do limite.
 Escreva um programa 
para determinar o valor 
da multa.
Problema 2
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas Velocidade km/h ≥ 0
Saídas Multa R$ ≥ 0
Problema 2
3 – Projetar o algoritmo
V
F
início
vel
fim
multa ← 200 + 3 * (vel – lim)
vel > lim
multa ← 0
lim← 60
multa
Problema 2
4 – Codificar em Python
# Entrada de dados e definicao de constantes
vel = float(input("Informe a velocidade: "))
lim = 60 # Limite de velocidade
# Calculo do valor da multa
if (vel > lim):
multa = 200 + 3 * (vel – lim) 
else:
multa = 0
# Exibicao de resultados
print(multa)
005
Problema 2
5 – Testar o script resultante
40
km/h
40
km/h
40
km/h
60
km/h
60
km/h
60
km/h
80
km/h
80
km/h
80
km/h
Problema 3
 A equaçãode uma 
circunferência de raio 
R é  ଶ ଶ ଶ.
 Escreva um algoritmo 
que, dado um ponto P
qualquer, verifique se 
ele se encontra:
 Na circunferência
 No interior 
 No exterior
y
x
R
Problema 3
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Raio ‐‐‐ >= 0
Coordenada X de P ‐‐‐
Coordenada Y de P ‐‐‐
Saídas Localização de P ‐‐‐ {interior, exterior, na circunferência}
Problema 3
3 – Projetar algoritmo
X**2 + Y**2 == R**2
X**2 + Y**2 < R**2
Na 
circunferência
V
P é interno
F
P é externo
V F
Problema 3
3 – Projetar algoritmo
V
F
fim
Externo
C2
Interno
V
F
início
R, X, Y
Na 
circunferência
C1
X**2 + Y**2 == R**2C1
X**2 + Y**2 < R**2C2
006
Problema 3
4 – Codificar em Python
# Entrada de dados
r = float(input("Digite raio: "))
x = float(input("Digite coord. X do ponto: "))
y = float(input("Digite coord. Y do ponto: "))
if (x**2 + y**2 == r**2):
print("Ponto estah na circunferencia.")
else:
if (x**2 + y**2 < r**2):
print("Ponto eh interno.")
else:
print("Ponto eh externo.")
Problema 4
 Dados os coeficientes a, b, c de uma equação de 2º 
grau, determine se há raízes reais e, caso positivo, 
quais são elas.
Problema 4
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Coeficiente a ‐‐‐
Coeficiente b ‐‐‐
Coeficiente c ‐‐‐
Saídas
Raiz , se houver ‐‐‐
Raiz , se houver ‐‐‐
Problema 4
3 – Projetar algoritmo
V
F
início
a, b, c
fim
Não tem raiz 
real
delta < 0
r ← ‐ b/(2*a)
delta ← b**2 – 4*a*c
V
delta == 0
F
r
r1 ← (‐ b + delta)/(2*a)
r2 ← (‐ b ‐ delta)/(2*a)
r1, r2
Problema 4
4 – Codificar em Python
# Entrada de dadosa = float(input("Digite a: "))b = float(input("Digite b: "))c = float(input("Digite c: "))
delta = b**2 – 4 * a * c
if (delta < 0):print("Nao tem raiz real.")else:if (delta == 0):r = -b / (2 * a)print("Uma raiz real")print(r)else:r1 = (-b + delta**0.5) / (2 * a)r2 = (-b - delta**0.5) / (2 * a)print("Duas raizes reais:")print(r1)print(r2) 007
Problema 5
 Projete um algoritmo para uma máquina caça‐
níquel que gere 3 números aleatórios entre 1 e 10.
 Se os três números forem iguais, o jogador ganha. 
Caso contrário, ele perde.
Problema 5
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas
N1 ‐‐‐ [1,10]
N2 ‐‐‐ [1,10]
N3 ‐‐‐ [1,10]
Saídas Sucesso no jogo ‐‐‐ {Perdeu, Ganhou}
Problema 5
3 – Projetar algoritmo
N1 == N2
N2 == N3perdeu
F
perdeu
V
ganhou
F V
Problema 5
3 – Projetar algoritmo
V
F
F
início
Gerar N1, N2, N3
Ganhou!
fim
N1 == N2
Perdeu!Perdeu!
N2 == N3
V
Como gerar números 
aleatórios?
Problema 5
4 – Codificar em Python
# Biblioteca de nos. aleatorios
import random
# Gera nos. aleatorios entre 1 e 10
n1 = random.randint(1,10)
n2 = random.randint(1,10)
n3 = random.randint(1,10)
if (n1 == n2):
if (n2 == n3):
print("Ganhou")
else:
print("Perdeu")
else:
print("Perdeu")
008
Módulos em Python (Bibliotecas)
 Bibliotecas organizam 
funções bastante 
utilizadas em arquivos 
diferentes.
 Assim, elas podem ser 
chamadas quando 
necessário, sem ter de 
reescrever tudo.
 Em Python, as 
bibliotecas também são 
conhecidas como 
módulos. Uso:<módulo>.<função>
Conteúdo
Estruturas Condicionais Simples
Estruturas Condicionais Compostas
Como montar uma condição?
Estruturas Condicionais Encadeadas
Tipos de operadores
Resultado
(saída)
Operandos
(entradas)
Tipo.
Operadores
Aritmético numérico numérico
Relacional numérico lógico
Lógico lógico lógico
Precedência entre operadores
Operador Significado Precedência
() Grupos entre parênteses +
** Potenciação
- Negação
* / % // Multiplicação, divisão real, resto, divisão inteira
+ - Subtração, adição
> >= < <= == != Comparações
not NÃO lógico
and E lógico
or OU lógico
= Atribuição –
Exemplos
(x <= 20 or x >= 40) (salario > 1000 andidade > 18)
x resultado
10
20
30
40
50
V
V
F
V
V
salario idade resultado
900 18
1000 19
1100 17
1200 22
F
F
F
V
Exemplos
(m – 4 > m / 2) (num % 2 != 0 andcontador < 50)
m resultado
2
8
30
F
F
V
num contador resultado
1231 51
1232 50
1233 49
1234 48
F
F
F
V
Atenção
:: Compare variáveis do mesmo tipo
 No exemplo acima, a variável x é do tipo inteiro, 
mas a expressão "4" representa um caractere, e 
não um número.
x = 4
if ("4" == x):
print("igual")
else:
print("diferente")
009
Armadilhas
:: Números float são aproximações
 Há infinitos números 
reais.
 A memória do 
computador é um 
recurso finito.
 Logo, não há como 
representar todos os 
números reais em 
memória.
 Consequentemente, 
representamos 
aproximações.
u = 11111113
v = -11111111
w = 7.51111111
print((u + v) + w)
print(u + (v + w))
u + (v + w) == (u + v) + w
9.51111111
9.511111110448837
False
010
Estabeleça um nível mínimo de 
precisão
Alternativa 1 Alternativa 2
u = 11111113
v = -11111111
w = 7.51111111
x = (u + v) + w
y = u + (v + w)
x == y
round(x,6) == round(y,6)
False
True
u = 11111113
v = -11111111
w = 7.51111111
x = (u + v) + w
y = u + (v + w)
x == y
abs(x-y) < 0.0000001
False
True
011
Funções round e abs
 Arredonda um 
número x em n casas 
decimais.
 Determina o módulo 
de um número real z, 
ou seja, sua distância 
até o zero.
round(x, n) abs(z)
Problema 6
 Dados três valores X, Y e Z, verifique:
 Se eles podem ser os comprimentos dos lados de um 
triângulo.
 Caso positivo, se o triângulo é equilátero, isósceles ou 
escaleno.
Problema 6
1 – Identificar o problema
 Propriedade básica de um triângulo:
 O comprimento de cada lado de um triângulo é menor
do que a soma dos comprimentos dos demais lados.
Triângulo cujos 
os lados têm 
comprimentos 
iguais.
Equilátero
Triângulo que 
tem dois lados 
com 
comprimentos 
iguais.
Isósceles
Triângulo que 
tem os três 
lados com 
comprimentos 
diferentes.
Escaleno
Problema 6
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas
X m > 0
Y m > 0
Z m > 0
Saídas mensagem ‐‐‐
“Não é triângulo”,
“Triângulo equilátero”,
“Triângulo isósceles”,
“Triângulo escaleno”
Problema 6
3 – Projetar algoritmo
V
F
fim
C2
Equilátero
V
F
início
X, Y, Z
Não é 
triângulo
C1
(X > Y + Z) OU (Y > Z + X) 
OU (Z > X + Y)C1
(X == Y) E (Y == Z)C2
(X == Y) OU (Y == Z) OU 
(Z == X)C3
V
F
Escaleno
C3
Isósceles
Problema 6
4 – Codificar em Python
# Entrada de dados
a = float(input("Digite o lado a: "))
b = float(input("Digite o lado b: "))
c = float(input("Digite o lado c: "))
if ((a >= b + c) or (b >= a + c) or (c >= b + a)):
print("Nao eh triangulo.")
else:
if ((a == b) and (b == c)):
print("Triangulo equilatero")
else:
if ((a == b) or (b == c) or (c == a)):
print("Triangulo isosceles")
else:
print("Triangulo escaleno")
012
Problema 7
 Sejam A, B, C três números inteiros quaisquer.
 Escreva um fluxograma para arrumá‐los em ordem 
decrescente.
Problema 7
1 – Identificar o problema
 São dados três números quaisquer A, B, C.
 Eles devem ser arrumados em ordem decrescente. Pode‐se considerar que a saída seja
N1 ≥ N2 ≥ N3
 Agora, o problema se resume a atribuir:
A
B
C
N1
N2
N3
Problema 7
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas A, B, C ‐‐‐ Inteiros, qualquer ordem
Saídas N1, N2, N3 ‐‐‐ Inteiros, ordem decrescente
Problema 7
3 – Projetar algoritmo
A > B
C > N1
N1 ← A
N2 ← B
V F
N1 ← B
N2 ← A
V F
N3 ← N2
N2 ← N1
N1 ← C
C > N2
N3 ← N2
N2 ← C
V F
N3 ← C
Problema 7
3 – Projetar algoritmo
V
F
fim
C > N1
N3 ← N2
N2 ← N1
N1 ← C
N1, N2, N3
V
F
início
A, B, C
N1 ← A
N2 ← B
A > B
V
F
N3 ← C
C > N2
N3 ← N2
N2 ← C
N1 ← B
N2 ← A
1
1
Problema 7
4 – Codificar em Python
# Entrada de dadosa = float(input("Digite o numero a: "))b = float(input("Digite o numero b: "))c = float(input("Digite o numero c: "))
if (a > b):n1 = an2 = belse:n1 = bn2 = a
if (c > n1):n3 = n2n2 = n1n1 = celse:if (c > n2):n3 = n2n2 = celse:n3 = c
print("Numeros em ordem:",n1,n2,n3)
013
Problema 8
 Um gerente quer medir 
a eficiência de 
processos em sua 
empresa.
 Um processo X 
começou no horário h1
e terminou no mesmo 
dia, no horário h2, 
também medido em 
horas e minutos.
 Quanto tempo durou o 
processo?
Problema 8
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Horário 1 (hh1, mm1) horas, minutos [0; 23], [0; 59]
Horário 1 (hh2, mm2) horas, minutos [0; 23], [0; 59]
Saídas Diferença de tempo(Δh, Δm) horas, minutos [0; 23], [0; 59]
Problema 8
3 – Projetar algoritmo
mm2 ≥ mm1 mm2 < mm1
Caso 1 Caso 2
Início:    9h 17min
Fim:  15h 43min
Δm = 43 – 17 = 26min
Δh =   15 – 9 =        6h
Início:    9h 43min
Fim:  15h 17min
Δm =     17 – 43 = 34min (‐1h)
Δh = 15 – 9 – 1 = 5h                
Problema 8
3 – Projetar algoritmo
dh = hh2 – hh1
fim
V
F
início
hh1, mm1
hh2, mm2
mm2 >= mm1
dh = hh2 – hh1 – 1
dm = (mm2 – mm1) % 60
dh, dm
Problema 8
4 – Codificar em Python
# Entrada de dados
hh1 = int(input("Hora inicial: "))
mm1 = int(input("Minuto inicial: "))
hh2 = int(input("Hora final: "))
mm2 = int(input("Minuto final: "))
# Diferenca de minutos
dm = (mm2 – mm1) % 60
# Diferenca de horas
if (mm2 >= mm1):
dh = hh2 – hh1
else:
dh = hh2 – hh1 – 1
print(dh, dm)
014
Problema 9
 Duas pessoas jogam pedra, papel, tesoura.
 Como determinar quem ganhou?
Problema 9
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Mão do J1 ‐‐‐ {Pedra, Papel, Tesoura}
Mão do J2 ‐‐‐ {Pedra, Papel, Tesoura}
Saídas Vencedor ‐‐‐ {J1, J2}
Problema 9
3 – Projetar algoritmo – versão 1
 Se J1 == J2
 Empate
 J1 ganha quando:
 (J1 == Pedra  E J2 == Tesoura) OU
 (J1 == Papel  E J2 == Pedra) OU
 (J1 == Tesoura  E J2 == Papel)
 J2 ganha caso contrário
Problema 9
3 – Projetar algoritmo – versão 1
V
F
Empate
fim
Jogador 2 
ganhou
C1
Jogador 1 
ganhou
V
F
início
Sortear J1, J2
J1 == J2
(J1 == Pedra E J2 == Tesoura) OU
(J1 == Papel E J2 == Pedra) OU
(J1 == Tesoura E J2 == Papel)
C1
Como fazer o 
sorteio?
Problema 9
4 – Codificar em Python – sorteio
# Sorteio do jogo "Pedra, Papel, Tesoura"
# Pedra = 0
# Papel = 1
# Tesoura = 2
import random
j1 = random.randint(0,2)
j2 = random.randint(0,2)
(J1 == Pedra E J2 == Tesoura) OU
(J1 == Papel E J2 == Pedra) OU
(J1 == Tesoura E J2 == Papel)
(J1 == 0 E J2 == 2) OU
(J1 == 1 E J2 == 0) OU
(J1 == 2 E J2 == 1)
Problema 9
4 – Codificar em Python – versão 1
if (j1 == j2):
print("Empate.")
else:
if (((j1 == 0) and (j2 == 2)) or ((j1 == 1) and (j2 
== 0)) or ((j1 == 2) and (j2 == 1))):
print("Jogador 1 ganhou.")
else:
print("Jogador 2 ganhou.")
015
Abstração
 Associar objetos (pedra, 
papel, tesoura) a números 
é uma forma de 
abstração.
 Adotamos essa abstração 
para simplificar o código 
do sorteio.
 Tal simplificação não 
poderia ser também 
aplicada ao teste da 
condição? 
Problema 9
:: Repensando o Jogo
1
02
1
02
1
02
Problema 9
:: Repensando o Jogo
 Por exemplo, é natural 
pensar que três horas 
antes de 2h no relógio 
resulta em 11h.
 Inconscientemente, 
fazemos as seguintes 
contas:
 2h – 3h = –1h
 –1h + 12h = 11h
Problema 9
:: Repensando o Jogo
0
2
1
2
0
1
1
2
0
Ganhou quem tirou o 
número uma unidade maior
Ganhou quem tirou o número uma 
unidade maior, se pensarmos 
como em um relógio de 3 posições
2 – 1 = 1
2 – 0 = 2
1 – 0 = 1
1 – 2 = ‐1
0 – 2 = ‐2
0 – 1 = ‐1
Operador %
 O operador % tem uma propriedade interessante:
a % b
Se a é positivo
• Resultado: resto da divisão
Se a é negativo
• Resultado: determinado por aritmética 
circular, como em um relógio.
Problema 9
:: Repensando o Jogo
1
02
(2 – 1) % 3 = 1
(2 – 0) % 3 = 2
1
02
1
02
(1 – 0) % 3 = 1
(1 – 2) % 3 = 2
(0 – 2) % 3 = 1
(0 – 1) % 3 = 2
Aritmética circular (ou modular)
0
12
[0 – 2] = ‐2
0
12
0
12
[0 – 1] = ‐1
0
12
0
12
[0 – 0] = 0
0
12
(0 – 2) % 3 = 1
(0 – 1) % 3 = 2
(0 – 0) % 3 = 0
Uma casa 
para trás
Duas casas 
para trás
Zero casas 
para trás
Problema 9
3 – Projetar algoritmo – versão 2
V
F
Empate
fim
Jogador 2 
ganhou
(J1‐J2)%3 == 1
Jogador 1 
ganhou
V
F
início
Sortear J1, J2
J1 == J2
Teste esta condição no Shell 
do Python, para todas as 
possibilidades de J1 e J2
Problema 9
4 – Codificar em Python – versão 2
# Sorteio do jogo "Pedra, Papel, Tesoura"
# Pedra = 1
# Papel = 2
# Tesoura = 3
import random
j1 = random.randint(0,2)
j2 = random.randint(0,2)
if (j1 == j2):
print("Empate.")
else:
if ((j1 – j2) % 3 == 1):
print("Jogador 1 ganhou.")
else:
print("Jogador 2 ganhou.")
016
Módulo math
 Contém diversas 
funções que podem 
ser usadas   em 
cálculos matemáticos.
 Para utilizá‐las, não se 
esqueça de colocar o 
prefixo math. antes 
do nome da função.
Módulo math
:: Funções matemáticas e constantes
• Calcula exexp(x)
• Logaritmo natural de x (base e)log(x)
• Logaritmo de x na base 10log10(x)
• Raiz quadrada de xsqrt(x)
• Valor da constante PiPi
• Valor da constante de Eulere
Módulo math
:: Funções trigonométricas
• Calcula o seno de x (em radianos)sin(x)
• Calcula o cosseno de x (em radianos)cos(x)
• Calcula a tangente de x (em radianos)tan(x)
• Calcula o arco‐seno de xasin(x)
• Calcula o arco‐cosseno de xacos(x)
• Calcula o arco‐tangente de xatan(x)
Módulo math
:: Funções de arredondamento
• Arredonda x para o inteiro mais 
próximo em direção a mais infinitoceil(x)
• Arredonda x para o inteiro mais 
próximo em direção a menos 
infinito
floor(x)
Funções de arredondamento
:: Diferenças
ceil() e 
floor()
• Requer módulo 
math.
• Possui apenas um
argumento de 
entrada.
• Resulta é um 
número inteiro.
round()
• É padrão do Python. 
Não requer o 
módulo math.
• Possui dois
argumentos de 
entrada.
• Resultado é um 
número real.
Problema 10
 Calcular o alcance 
de um projétil, dados 
a velocidade inicial  ଴
e o ângulo  entre o 
cano do canhão e o 
solo. Considere 
ଶ.
଴
ଶ
Problema 10
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Velocidadeinicial m/s > 0
Ângulo com solo graus
Saídas Alcance m > 0
Problema 10
3 – Projetar algoritmo
fim
F
V
início
v0, theta
Dados 
inválidos
C1
(v0 >= 0)  and (theta > 0) and
(theta < 90)C1
s = (v0**2 / g) * sen(2 * theta)
g = 9.81
s
Problema 10
4 – Codificar em Python
017
# Entrada de dados e definicao de constantes
v0 = float(input("Velocidade inicial: "))
theta_g = float(input("Angulo: "))
g = 9.81
# Importar modulo matematico
import math
if (v0 >= 0) and (theta_g > 0) and (theta_g < 90):
theta_rad = theta_g * math.pi / 180.0
s = (v0**2 / g) * math.sin(2 * theta_rad)
print(round(s, 3))
else:
print("Dados invalidos.")
Problema 11
 Uma quantia inicial  é 
aplicada a uma taxa  de 
juros. O saldo  desse 
investimento após 
meses é dado por:
௠
 Para uma taxa  ao mês, 
quanto tempo (em anos e 
meses) é necessário para 
que o saldo dobre em 
relação ao valor inicial?
Problema 11
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas Taxa de juros (t) ‐‐‐ [0; 1]
Saídas m (tempo) anos; meses [0, +∞[; [0, 11]
Problema 11
3 – Projetar algoritmo
 A saída do problema é 
a quantidade de 
meses e anos, mas a 
saída da equação é o 
saldo, informação que 
já conhecemos.
 Portanto, temos de 
reescrever a equação, 
isolando o  no lado 
esquerdo.
௠
௠
௠
Problema 11
3 – Projetar algoritmo
 A expressão anterior 
resultará em um 
número com parte 
fracionária.
 Contudo, o valor da 
saída é inteiro, pois o 
rendimento acontece 
a cada mês.
 Logo, o resultado deve 
ser arredondado para 
cima (math.ceil)
Problema 11
3 – Projetar algoritmo
fim
F
V
início
t
Dados 
inválidos
(t >= 0) and (t <= 1)
m = log(2) / log(1 + t)
m % 12
m // 12
Problema 11
4 – Codificar em Python
# Entrada de dados
t = float(input("Informe a taxa de aplicacao: "))
if ((t >= 0) and (t <= 1)):
# Importar modulo matematico
import math
m = math.ceil(math.log(2) / math.log(1 + t))
print(m // 12) # no. de anos
print(m % 12) # no. de meses (0 a 11)
else:
print("Dados invalidos")
018
Conteúdo
Estruturas Condicionais Simples
Estruturas Condicionais Compostas
Como montar uma condição?
Estruturas Condicionais Encadeadas
Estruturas Condicionais Encadeadas
 Estruturas condicionais encadeadas (ou aninhadas) 
são estruturas condicionais dentro de outras 
estruturas condicionais.
 Quando um problema exige um longo 
encadeamento de ifs e elses, a criação de 
diversos níveis deslocados poderia causar 
confusão.
 A cláusula elif substitui um par else if sem 
criar um outro nível na estrutura condicional.
Estruturas Condicionais Encadeadas
:: Exemplo
if (delta < 0):
print("Nao tem raiz real")
elif (delta == 0):
r1 = -b/(2 * a)
else:
r1 = (-b + delta**0.5)/(2*a)
r2 = (-b – delta**0.5)/(2*a)
Calcular r1 
e r2
Δ<0
F
V
Sem 
solução
Calcular 
r1
Δ=0
V
F
fim
if (delta < 0):
print("Nao tem raiz real")
else:
if (delta == 0):
r1 = -b/(2 * a)
else:
r1 = (-b+delta**0.5)/(2*a)
r2 = (-b–delta**0.5)/(2*a)
Problema 12
 Escrever um script em Python que leia um ângulo 
entre 0 e 360° e informe o ponto cardeal 
correspondente.
0°
Problema 12
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas Ângulo graus
Saídas Ponto Cardeal ‐‐‐ {N, S, L, O}
Problema 12
3 – Projetar algoritmo
F
F
F
F
V
V
V
V
início
ang
fim
ang == 0 or
ang == 360
Norte
ang == 180
ang == 90
Sul
Leste
Desconhecido
ang == 270 Oeste
xxx
Problema 12
4 – Codificar em Python
# Entrada de dados
ang = int(input("Digite o valor de um angulo: "))
if ((ang == 0) or (ang == 360)):
print("Norte")
elif (ang == 180):
print("Sul")
elif (ang == 90):
print("Leste")
elif (ang == 270):
print("Oeste")
else:
print("Desconhecido")
Problema 13
 Anos bissextos são definidos da 
seguinte forma:
1. Anos divisíveis por 400 são 
bissextos.
2. Anos divisíveis por 100, mas 
não por 400, não são 
bissextos.
3. Anos divisíveis por 4, mas não 
por 100, são bissextos.
4. Todos os outros anos não são 
anos bissextos.
 Escreva um fluxograma que 
determine se um ano é 
bissexto ou não.
Problema 13
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas Ano ‐‐‐
Saídas Mensagem ‐‐‐ {bissexto, não bissexto}
Problema 13
3 – Projetar algoritmo – versão 1
ano % 400 == 0
ano % 100 == 0Bissexto
V
Não 
bissexto
F
V F
ano % 4 == 0
Bissexto Não bissexto
V F
Problema 13
3 – Projetar algoritmo – versão 1
V
F
fim
C2
Não 
bissexto
V
F
início
ano
Bissexto
C1
ano % 400 == 0C1
ano % 100 == 0C2
ano % 4 == 0C3
V
F
Não 
bissexto
C3
Bissexto
Problema 13
4 – Codificar em Python – versão 1
xxx
# Entrada de dados
ano = int(input("Digite o ano: "))
# Verifica se ano eh bissexto
if (ano % 400 == 0):
print("Bissexto")
elif (ano % 100 == 0):
print("Nao Bissexto")
elif (ano % 4 == 0):
print("Bissexto")
else:
print("Nao Bissexto")
Problema 13
3 – Projetar algoritmo – versão 2
ano % 400 == 0
ano % 100 == 0Bissexto
V
Não 
bissexto
F
V F
ano % 4 == 0
Bissexto Não bissexto
V F
Bissexto: ano % 400 == 0 (ano % 100 ≠ 0) E (ano % 4 == 0)OU
Problema 13
3 – Projetar algoritmo – versão 2
fim
Não 
bissexto
V F
início
ano
Bissexto
C1
(ano % 400 == 0)
OU
((ano % 100 ≠ 0) E (ano % 4 == 0))
C1
Problema 13
4 – Codificar em Python – versão 2
xxx
# Entrada de dados
ano = int(input("Digite o ano: "))
# Verifica se ano eh bissexto
if ((ano%400 == 0) or ((ano%100 != 0) and (ano%4 == 0))):
print("Bissexto")
else:
print("Nao Bissexto")
Problema 14
 A partir da renda 
mensal, como 
determinar o valor do 
imposto de renda 
devido?
 Importante: as 
alíquotas são 
aplicadas de forma 
progressiva.
Problema 14
2 – Definir entradas e saídas
Grandeza Unidade de medida Faixa de valores
Entradas
Saídas
Grandeza Unidade de medida Faixa de valores
Entradas Renda R$ ≥ 0
Saídas Imposto R$ ≥ 0
Problema 14
3 – Projetar algoritmo
 O que é o cálculo progressivo?
 Uma pessoa que recebe R$ 1.500 mensais não pagará 
imposto de 7,5% sobre os R$ 1.500, mas sim sobre a 
diferença (1500,00 – 1499,15 = 0,85).
 Da mesma maneira, quem recebe R$ 2.500 pagará:
 7,5% de (2246,75 – 1499,15)
 15% de (2500 – 2246,75)
 E assim por diante... Faixa de renda mensal Alíquota
Até R$ 1.499,15 Isento
De R$ 1.499,16 até R$ 2.246,75 7,5%
De R$ 2.246,76 até R$ 2.995,70 15%
De R$ 2.995,71 até R$ 3.743,19 22,5%
acima de R$ 3.743,19 27,5%
Problema 14
3 – Projetar algoritmo
 Para simplificar o desenho do fluxograma, vamos 
adotar as seguintes convenções:
Faixa de renda mensal Constante
R$ 1.499,15 V1
R$ 2.246,75 V2
R$ 2.995,70 V3
R$ 3.743,19 V4
Problema 14
3 – Projetar algoritmo – versão 1
início
R
R > V1 V
imp← 0,075*(R‐V1)
F
R > V2 R > V3
F F
V VR > V4
F
V
imp← 0
imp← 0,075*(V2‐V1) +
0,15*(R‐V2)
imp← 0,075*(V2‐V1) +
0,15*(V3‐V2) +
0,225*(R‐V3)
imp← 0,075*(V2‐V1) +
0,15*(V3‐V2) +
0,225*(V4‐V3)+
0,275*(R‐V4)
fim
imp
Versão usada na aula anterior
V
Problema 14
3 – Projetar algoritmo – versão 2
início
R
R <= V1 F
imp← 0,075*(R‐V1)
R <= V2 R <= V3
V V
F FR <= V4
VF
imp← 0
imp← 0,075*(V2‐V1) +
0,15*(R‐V2)
imp← 0,075*(V2‐V1) +
0,15*(V3‐V2) +
0,225*(R‐V3)
imp← 0,075*(V2‐V1) +
0,15*(V3‐V2) +
0,225*(V4‐V3)+
0,275*(R‐V4)
fim
imp
Facilita uso do elif
Problema 14
4 – Codificar em Python
xxx
# Entrada de dados e definicao de constantes
r = float(input("Digite sua renda: "))
v1 = 1499.15
v2 = 2246.75
v3 = 2995.70
v4 = 3743.19
if (r <= v1):
imp = 0
elif (r <= v2):
imp = 0.075*(r-v1)
elif (r <= v3):
imp = 0.075*(v2-v1) + 0.15*(r-v2)
elif (r <= v4):
imp = 0.075*(v2-v1) + 0.15*(v3-v2) + 0.225*(r-v3)
else:
imp = 0.075*(v2-v1) + 0.15*(v3-v2) + 0.225*(v4-v3) 
+ 0.275*(r-v4)
print(imp)
Estruturas Condicionais
:: Revisão
Estruturas 
Condicionais
Simples
(if)
Composta
(if ... else)
Múltipla escolha
(if ... elif ... else)
Referências bibliográficas
 Menezes, Nilo Ney Coutinho (2010). Introdução à 
Programação com Python. Editora Novatec.
 HETLAND, Magnus Lie (2008). Beginning Python: 
From Novice to Professional. Springer eBooks, 2ª 
edição. Disponível em: 
http://dx.doi.org/10.1007/978‐1‐4302‐0634‐7.
 Gaddis, Tony (2012). Starting out with Python, 2ª 
edição. Editora Addison‐Wesley.
 DIERBACH, Charles. Introduction to Computer 
Science using Python: a computational problem‐
solving approach. John Wiley & Sons, 2012.
Dúvidas?