Aula10_EstruturasCondicionais(Python)_Elaine

Prévia do material em texto

IEC037 
Introdução à Programação de Computadores 
Aula 10 – Estruturas Condicionais em Python 
Turmas: Engenharias Mecânica e de Materiais 
Professora: Elaine Harada Teixeira de Oliveira 
E-mail: elaine@icomp.ufam.edu.br 
Ambiente virtual: http://colabweb.ufam.edu.br 
Curso: 2014/01 Introdução à Programação de Computadores - 
Engenharias Mecânica e de Materiais 
 
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/ direita 
p/ baixo a = 3 
b = 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') 
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: ")) 
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") 
delta = 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") 
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 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: ")) 
delta = 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 
V t > 25 
Tchau 
Quente 
Ligue o ... 
003 
F 
V t > 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 
60 
km/h 
80 
km/h 
Problema 3 
 A equação de uma 
circunferência de raio 
R é 𝑥2 + 𝑦2 = 𝑅2. 
 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**2 C1 
X**2 + Y**2 < R**2 C2 
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 dados 
a = 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 == N3 perdeu 
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 numeros aleatorios 
import random 
 
# Gera numeros 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> 
Simplificando o uso de módulos 
Python 
 Se ao longo do código você usa diversas vezes 
funções pertencentes a um módulo Python, a 
programação pode se tornar cansativa. 
 Para usar diretamente o nome da função sem 
explicitar o nome do módulo como prefixo, use o 
seguinte comando: 
from <nome_do_módulo> import * 
Pode ser o math, o random ou 
outro que você necessitar. 
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 and 
idade > 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 and 
contador < 50) 
m resultado 
2 
8 
30 
F 
F 
V 
num contador resultado 
1231 51 
1232 50 
1233 49 
1234 48 
F 
F 
V 
F 
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 dados 
a = int(input("Digite o numero a: ")) 
b = int(input("Digite o numero b: ")) 
c = int(input("Digite o numero c: ")) 
 
if (a > b): 
 n1 = a 
 n2 = b 
else: 
 n1 = b 
 n2 = a 
 
if (c > n1): 
 n3 = n2 
 n2 = n1 
 n1 = c 
else: 
 if (c > n2): 
 n3 = n2 
 n2 = c 
 else: 
 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, Empate} 
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 
from random import * 
 
j1 = randint(0,2) 
j2 = 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 
0 2 
1 
0 2 
1 
0 2 
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 
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. 
Aritmética circular (ou modular) 
0 
1 2 
[0 – 1] = 2 
0 
1 2 
0 
1 2 
[0 – 2] = 1 
0 
1 2 
0 
1 2 
[0 – 3] = 0 
0 
1 2 
(0 – 1) % 3 = 2 
(0 – 2) % 3 = 1 
(0 – 3) % 3 = 0 
Uma casa 
para trás 
Duas casas 
para trás 
Três casas 
para trás 
Problema 9 
:: Repensando o Jogo 
0 
2 
1 
2 
0 
1 
1 
2 
0 
(2 – 1) % 3 = 1 
(2 – 0) % 3 = 2 
(1 – 0) % 3 = 1 
(1 – 2) % 3 = 2 
(0 – 2) % 3 = 1 
(0 – 1) % 3 = 2 
O resultado determina 
quem ganhou: 
1: Jogador 1 
2: Jogador 2 
Problema 9 
:: Repensando o Jogo 
1 
0 2 
(2 – 1) % 3 = 1 
(2 – 0) % 3 = 2 
1 
0 2 
1 
0 2 
(1 – 0) % 3 = 1 
(1 – 2) % 3 = 2 
(0 – 2) % 3 = 1 
(0 – 1) % 3 = 2 
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 = 0 
# Papel = 1 
# Tesoura = 2 
from random import * 
 
j1 = randint(0,2) 
j2 = 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 ex exp(x) 
• Logaritmo natural de x (base e) log(x) 
• Logaritmo de x na base 10 log10(x) 
• Raiz quadrada de x sqrt(x) 
• Valor da constante Pi Pi 
• Valor da constante de Euler e 
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 x asin(x) 
• Calcula o arco-cosseno de x acos(x) 
• Calcula o arco-tangente de x atan(x) 
Módulo math 
:: Funções de arredondamento 
• Arredonda x para o inteiro mais 
próximo em direção a mais infinito 
ceil(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 𝑣0 
e o ângulo 𝜃 entre o 
cano do canhão e o 
solo. Considere 
𝑔 = 9,81𝑚/𝑠2. 
𝑆 =
𝑣0
2
𝑔
sen(2𝜃) 
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 
Velocidade inicial m/s >= 0 
Ângulo com solo graus ]0; 90[ 
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 
from math import * 
 
if (v0 >= 0) and (theta_g > 0) and (theta_g < 90): 
 theta_rad = theta_g * pi / 180.0 
 s = (v0**2 / g) * 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: 
𝑠 = 𝑞 1 + 𝑡 𝑚 
 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. 
𝑠 = 𝑞 1 + 𝑡 𝑚 
2𝑞
𝑞
= 1 + 𝑡 𝑚 
log 2 = log 1 + 𝑡 𝑚 
log 2 = 𝑚 ⋅ log 1 + 𝑡 
𝑚 =
log 2
log 1 + 𝑡
 
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) 
𝑚 =
log 2
log 1 + 𝑡
 
Problema 11 
3 – Projetar algoritmo 
fim 
F 
V 
início 
t 
Dados 
inválidos 
(t >= 0) and (t <= 1) 
m = ceil( log(2) / log(1 + t) ) 
m % 12 
m // 12 anos 
meses 
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 
 from math import * 
 
 m = ceil(log(2) / 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 [0; 360] 
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 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 == 0 Bissexto 
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 == 0 C1 
ano % 100 == 0 C2 
ano % 4 == 0 C3 
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("NaoBissexto") 
elif (ano % 4 == 0): 
 print("Bissexto") 
else: 
 print("Nao Bissexto") 
Problema 13 
3 – Projetar algoritmo – versão 2 
ano % 400 == 0 
ano % 100 == 0 Bissexto 
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 V 
R > 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 F 
R <= V4 
V 
F 
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?