Apresentação do PowerPoint

IEC037
Introdução à Programação de Computadores
Aula 09 – Estruturas Condicionais em Python
Turma: 03
Professor: Leandro Galvão
E-mail: [email protected]
Página: ipc-t03.weebly.com
Resolução de Problemas Algorítmicos
Início
1
Identificar o problema
2
Definir as entradas e as
saídas
Decompor
3
Projetar o algoritmo
4
Converter o algoritmo em
declarações da linguagem de
programação
5
Testar o programa
resultante
Fim
Refinar
passo a passo
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 = 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,
 Falsidade
ou
?
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.
início
a, b, c
delta ← b**2 – 4*a*c
delta < 0
F
if (delta < 0):
print('Nao tem raizes reais')
fim
V
Não tem
raízes reais
Estrutura Condicional Simples
:: Em Python
a = float(input("Digite a: "))
b = float(input("Digite b: "))
c = float(input("Digite c: "))
delta = b**2 – 4 * a * c
início
a, b, c
delta ← b**2 – 4*a*c
delta < 0 v
if (delta < 0):
print("Nao tem raizes reais")
F
Condições sempre terminam
com sinal de dois pontos
Comandos internos às condições
devem ser recuados (tecla TAB)
fim
Não tem
raízes reais
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.
início
a, b, c
delta ← b**2 – 4*a*c
delta < 0
V
F
if (delta < 0):
print("Nao tem raiz real")
else:
print("Tem raiz real")
Tem raiz
real
fim
Não tem
raízes reais
Estruturas Condicionais Compostas
:: Em Python
início
a = float(input("Digite a: "))
b = float(input("Digite b: "))
a, b, c
c = float(input("Digite c: "))
delta = b**2 – 4 * a * c
delta ← b**2 – 4*a*c
delta < 0
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
V
F
Tem raiz
real
fim
Não tem
raízes reais
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
if (condição):
comando
comando
else:
comando
comando
Indentação Inválida
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")
t > 25
F
V
Quente
Ligue o ...
Tchau
if (temp > 25):
print("Quente")
print("Ligue o ventilador")
print("Tchau")
t > 25
F
V
Quente
Ligue o ...
Tchau
003
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
Entradas
Saídas
Grandeza
Unidade de medida
Faixa de valores
PrecoA
R$
8.39
PesoA
kg
0.4
PrecoB
R$
20.30
PesoB
kg
1.0
Marca
---
{“A”, “B”}
Problema 1
3 – Projetar algoritmo
início
PrecoA, PesoA
PrecoB, PesoB
rA ← PrecoA/PesoA
rB ← PrecoB/PesoB
rA > rB
F
marca ← “A”
marca
fim
V
marca ← “B”
Problema 1
4 – Codificar em Python
# Entrada de dados
pA = float(input("Digite
pB = float(input("Digite
mA = float(input("Digite
mB = float(input("Digite
o
o
o
o
preco da marca A: "))
preco da marca B: "))
peso da marca A: "))
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
Entradas
Saídas
Grandeza
Unidade de medida
Faixa de valores
Velocidade
km/h
≥0
Multa
R$
≥0
Problema 2
3 – Projetar o algoritmo
início
vel
lim ← 60
vel > lim
F
V
multa ← 200 + 3 * (vel – lim)
multa
fim
multa ← 0
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
if (vel >
multa
else:
multa
do valor da multa
lim):
= 200 + 3 * (vel – lim)
= 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
R
x
Problema 3
2 – Definir entradas e saídas
Entradas
Saídas
Saídas
Grandeza
Unidade de medida
Faixa de valores
Raio
---
>= 0
Coordenada X de P
---
ℝ
Coordenada Y de P
---
ℝ
Localização de P
---
{interior, exterior, na
circunferência}
Problema 3
3 – Projetar algoritmo
X**2 + Y**2 == R**2
F
V
Na
circunferência
X**2 + Y**2 < R**2
V
P é interno
F
P é externo
Problema 3
3 – Projetar algoritmo
início
C1 X**2 + Y**2 == R**2
R, X, Y
C1
V
Na
circunferência
C2
F
C2
X**2 + Y**2 < R**2
F
V
Interno
fim
Externo
Problema 3
4 – Codificar em Python
#
r
x
y
Entrada de dados
= float(input("Digite raio: "))
= float(input("Digite coord. X do ponto: "))
= 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.")
006
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
Entradas
Saídas
Grandeza
Unidade de medida
Faixa de valores
Coeficiente a
---
ℝ
Coeficiente b
---
ℝ
Coeficiente c
---
ℝ
Raiz , se houver
---
ℝ
Raiz , se houver
---
ℝ
Problema 4
3 – Projetar algoritmo
início
a, b, c
delta ← b**2 – 4*a*c
delta < 0
V
Não tem raiz
real
F
delta == 0
V
r ← - b/(2*a)
r
fim
F
r1 ← (- b + delta)/(2*a)
r2 ← (- b - delta)/(2*a)
r1, r2
Problema 4
4 – Codificar em Python
#
a
b
c
Entrada de dados
= float(input("Digite a: "))
= float(input("Digite b: "))
= 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çaní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
Entradas
Saídas
Grandeza
Unidade de medida
Faixa de valores
N1
---
[1,10]
N2
---
[1,10]
N3
---
[1,10]
Sucesso no jogo
---
{Perdeu, Ganhou}
Problema 5
3 – Projetar algoritmo
N1 == N2
V
F
perdeu
N2 == N3
F
perdeu
V
ganhou
Problema 5
3 – Projetar algoritmo
início
Gerar N1, N2, N3
N1 == N2
F
V
N2 == N3
F
V
Ganhou!
Perdeu!
Perdeu!
Como gerar números
aleatórios?
fim
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
Uso:
módulos.
<módulo>.<função>
Conteúdo
Estruturas Condicionais Simples
Estruturas Condicionais Compostas
Como montar uma condição?
Estruturas Condicionais Encadeadas
Tipos de operadores
.
Operadores
Operandos
Resultado
(entradas)
(saída)
Aritmético
numérico
numérico
Relacional
numérico
lógico
Lógico
lógico
lógico
Tipo
Precedência entre operadores
Operador
Significado
()
Grupos entre parênteses
**
Potenciação
-
Multiplicação, divisão real,
resto, divisão inteira
+ >=
<
<= ==
+
Negação
* / % //
>
Precedência
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)
x
10
20
30
40
50
resultado
V
V
F
V
V
(salario > 1000 and
idade > 18)
salario idade
900
1000
1100
18
19
17
1200
22
resultado
F
F
F
V
Exemplos
(m – 4 > m / 2)
m
2
8
30
resultado
F
F
V
(num % 2 != 0 and
contador < 50)
num
contador
resultado
1231
1232
1233
51
50
49
1234
48
F
F
F
V
Atenção
:: Compare variáveis do mesmo tipo
x = 4
if ("4" == x):
print("igual")
else:
print("diferente")

No exemplo acima, a variável x é do tipo inteiro,
mas a expressão "4" representa um caractere, e
não um número.
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)
9.51111111
print(u + (v + w))
9.511111110448837
u + (v + w) == (u + v) + w
False
010
Estabeleça um nível mínimo de
precisão
Alternativa 1
Alternativa 2
u
v
w
x
y
u
v
w
x
y
=
=
=
=
=
11111113
-11111111
7.51111111
(u + v) + w
u + (v + w)
x == y
False
round(x,6) == round(y,6)
True
=
=
=
=
=
11111113
-11111111
7.51111111
(u + v) + w
u + (v + w)
x == y
False
abs(x-y) < 0.0000001
True
011
Funções round e abs
round(x, n)

Arredonda um
número x em n casas
decimais.
abs(z)

Determina o módulo
de um número real z,
ou seja, sua distância
até o zero.
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.
Equilátero
Isósceles
Escaleno
Triângulo cujos
os lados têm
comprimentos
iguais.
Triângulo que
tem dois lados
com
comprimentos
iguais.
Triângulo que
tem os três
lados com
comprimentos
diferentes.
Problema 6
2 – Definir entradas e saídas
Entradas
Saídas
Saídas
Grandeza
Unidade de medida
Faixa de valores
X
m
>0
Y
m
>0
Z
m
>0
---
“Não é triângulo”,
“Triângulo equilátero”,
“Triângulo isósceles”,
“Triângulo escaleno”
mensagem
Problema 6
3 – Projetar algoritmo
início
X, Y, Z
C1
V
(X > Y + Z) OU (Y > Z + X)
OU (Z > X + Y)
C2
(X == Y) E (Y == Z)
C3
(X == Y) OU (Y == Z) OU
(Z == X)
F
C2
V
Não é
triângulo
C1
F
C3
Equilátero
fim
V
Isósceles
F
Escaleno
Problema 6
4 – Codificar em Python
#
a
b
c
Entrada de dados
= float(input("Digite o lado a: "))
= float(input("Digite o lado b: "))
= 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
Entradas
Saídas
Grandeza
Unidade de medida
A, B, C
---
N1, N2, N3
---
Faixa de valores
Inteiros, qualquer
ordem
Inteiros, ordem
decrescente
Problema 7
3 – Projetar algoritmo
A>B
V
F
N1 ← A
N2 ← B
N1 ← B
N2 ← A
C > N1
V
F
N3 ← N2
N2 ← N1
N1 ← C
C > N2
V
N3 ← N2
N2 ← C
F
N3 ← C
Problema 7
3 – Projetar algoritmo
início
1
A, B, C
A>B
V
C > N1 F
V
F
C > N2 F
V
N1 ← B
N2 ← A
N1 ← A
N2 ← B
N3 ← N2
N2 ← N1
N1 ← C
N3 ← N2
N2 ← C
1
N1, N2, N3
fim
N3 ← C
Problema 7
4 – Codificar em Python
#
a
b
c
Entrada de dados
= float(input("Digite o numero a: "))
= float(input("Digite o numero b: "))
= float(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
Entradas
Saídas
Saídas
Grandeza
Unidade
Unidadede
demedida
medida
Faixa
Faixade
devalores
valores
Horário 1 (hh1, mm1)
horas, minutos
[0; 23], [0; 59]
Horário 1 (hh2, mm2)
horas, minutos
[0; 23], [0; 59]
Diferença de tempo
(Δh, Δm)
horas, minutos
[0; 23], [0; 59]
Problema 8
3 – Projetar algoritmo
Caso 1
Caso 2
mm2 ≥ mm1
mm2 < mm1
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
início
hh1, mm1
hh2, mm2
dm = (mm2 – mm1) % 60
mm2 >= mm1
F
V
dh = hh2 – hh1
dh = hh2 – hh1 – 1
dh, dm
fim
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
Entradas
Saídas
Grandeza
Unidade
Unidadede
demedida
medida
Faixa
Faixade
devalores
valores
Mão do J1
---
{Pedra, Papel, Tesoura}
Mão do J2
---
{Pedra, Papel, Tesoura}
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
início
C1
Sortear J1, J2
J1 == J2
V
(J1 == Pedra E J2 == Tesoura) OU
(J1 == Papel E J2 == Pedra) OU
(J1 == Tesoura E J2 == Papel)
F
C1
F
V
Empate
Jogador 1
ganhou
Jogador 2
ganhou
Como fazer o
sorteio?
fim
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
1
2
2
0
1
2
0
0
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
2
1
0
1
2–1=1
0
2–0=2
0
2
1–0=1
Ganhou quem tirou o
número uma unidade maior
1 – 2 = -1
2
0 – 2 = -2
1
0 – 1 = -1
Ganhou quem tirou o número uma
unidade maior, se pensarmos
como em um relógio de 3 posições
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
2
(2 – 1) % 3 = 1
0
1
2
(2 – 0) % 3 = 2
(1 – 0) % 3 = 1
0
(1 – 2) % 3 = 2
1
(0 – 2) % 3 = 1
2
0
(0 – 1) % 3 = 2
Aritmética circular (ou modular)
0
Uma casa
para trás
2
[0 – 2] = -2
1
0
Duas casas
para trás
2
2
(0 – 2) % 3 = 1
2
1
(0 – 1) % 3 = 2
2
(0 – 0) % 3 = 0
1
0
[0 – 0] = 0
1
1
0
[0 – 1] = -1
0
Zero casas
para trás
0
2
1
Problema 9
3 – Projetar algoritmo – versão 2
início
Teste esta condição no Shell
do Python, para todas as
possibilidades de J1 e J2
Sortear J1, J2
J1 == J2
V
F
(J1-J2)%3 == 1
F
V
Empate
Jogador 1
ganhou
fim
Jogador 2
ganhou
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
exp(x)
• Calcula ex
log(x)
• Logaritmo natural de x (base e)
log10(x)
sqrt(x)
Pi
e
• Logaritmo de x na base 10
• Raiz quadrada de x
• Valor da constante Pi
• Valor da constante de Euler
Módulo math
:: Funções trigonométricas
sin(x)
• Calcula o seno de x (em radianos)
cos(x)
• Calcula o cosseno de x (em radianos)
tan(x)
• Calcula a tangente de x (em radianos)
asin(x)
• Calcula o arco-seno de x
acos(x)
• Calcula o arco-cosseno de x
atan(x)
• Calcula o arco-tangente de x
Módulo math
:: Funções de arredondamento
ceil(x)
floor(x)
• Arredonda x para o inteiro mais
próximo em direção a mais infinito
• Arredonda x para o inteiro mais
próximo em direção a menos
infinito
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 .
𝑣02
𝑆=
sen(2𝜃)
𝑔
Problema 10
2 – Definir entradas e saídas
Entradas
Saídas
Grandeza
Unidade de medida
Faixa de valores
Velocidade inicial
m/s
>0
Ângulo com solo
graus
Alcance
m
>0
Problema 10
3 – Projetar algoritmo
início
(v0 >= 0) and (theta > 0) and
(theta < 90)
C1
v0, theta
g = 9.81
C1
F
Dados
inválidos
V
s = (v0**2 / g) * sen(2 * theta)
s
fim
Problema 10
4 – Codificar em Python
# Entrada
v0
=
theta_g =
g
=
de dados e definicao de constantes
float(input("Velocidade inicial: "))
float(input("Angulo: "))
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.")
017
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
Entradas
Saídas
Grandeza
Unidade de medida
Faixa de valores
Taxa de juros (t)
---
[0; 1]
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
início
t
(t >= 0) and (t <= 1)
V
F
m = log(2) / log(1 + t)
Dados
inválidos
m // 12
m % 12
fim
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
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
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")
else:
if (delta == 0):
r1 = -b/(2 * a)
else:
r1 = (-b+delta**0.5)/(2*a)
r2 = (-b–delta**0.5)/(2*a)
Δ<0
V
F
Δ=0
V
F
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
fim
Calcular
r1
Sem
solução
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
Entradas
Saídas
Grandeza
Unidade de medida
Ângulo
graus
Ponto Cardeal
---
Faixa de valores
{N, S, L, O}
Problema 12
3 – Projetar algoritmo
início
ang
ang == 0 or
ang == 360
F
ang == 180 V
V
Norte
Sul
F
ang == 90 V
F
ang == 270 V
F
Desconhecido
fim
Leste
Oeste
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")
xxx
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
Entradas
Saídas
Saídas
Grandeza
Unidade de medida
Ano
---
Mensagem
---
Faixa de valores
{bissexto,
não bissexto}
Problema 13
3 – Projetar algoritmo – versão 1
ano % 400 == 0
F
V
Bissexto
ano % 100 == 0
F
V
Não
bissexto
ano % 4 == 0
V
Bissexto
F
Não
bissexto
Problema 13
3 – Projetar algoritmo – versão 1
início
C1 ano % 400 == 0
ano
C2 ano % 100 == 0
C1
V
F
C3
C2
V
F
C3
F
V
Bissexto
Não
bissexto
fim
Bissexto
Não
bissexto
ano % 4 == 0
Problema 13
4 – Codificar em Python – versão 1
# 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")
xxx
Problema 13
3 – Projetar algoritmo – versão 2
ano % 400 == 0
F
V
Bissexto
ano % 100 == 0
F
V
Não
bissexto
ano % 4 == 0
V
Bissexto
Bissexto:
F
Não
bissexto
ano % 400 == 0 OU (ano % 100 ≠ 0) E (ano % 4 == 0)
Problema 13
3 – Projetar algoritmo – versão 2
C1
início
(ano % 400 == 0)
OU
((ano % 100 ≠ 0) E (ano % 4 == 0))
ano
V
C1
F
Não
bissexto
Bissexto
fim
Problema 13
4 – Codificar em Python – versão 2
# 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")
xxx
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
Entradas
Saídas
Grandeza
Unidade de medida
Faixa de valores
Renda
R$
≥0
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
R$ 2.995,70
R$ 3.743,19
V2
V3
V4
Problema 14
3 – Projetar algoritmo – versão 1
início
Versão usada na aula anterior
R
V
R > V1
F
R > V2
V
F
R > V3
F
V
R > V4
V
F
imp ← 0
imp ← 0,075*(R-V1)
imp ← 0,075*(V2-V1) +
0,15*(R-V2)
imp ← 0,075*(V2-V1) +
0,15*(V3-V2) +
0,225*(R-V3)
imp
fim
imp ← 0,075*(V2-V1) +
0,15*(V3-V2) +
0,225*(V4-V3)+
0,275*(R-V4)
Problema 14
3 – Projetar algoritmo – versão 2
início
Facilita uso do elif
R
R <= V1
V
F
R <= V2
F
R <= V3
V
V
F
R <= V4
F
V
imp ← 0
imp ← 0,075*(R-V1)
imp ← 0,075*(V2-V1) +
0,15*(R-V2)
imp ← 0,075*(V2-V1) +
0,15*(V3-V2) +
0,225*(R-V3)
imp
fim
imp ← 0,075*(V2-V1) +
0,15*(V3-V2) +
0,225*(V4-V3)+
0,275*(R-V4)
Problema 14
4 – Codificar em Python
# 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)
xxx
Estruturas Condicionais
:: Revisão
Simples
(if)
Estruturas
Condicionais
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 problemsolving approach. John Wiley & Sons, 2012.
Dúvidas?