Estruturas Condicionais

if; if else; if elif

Prof. Omero Francisco Bertol

(omero@utfpr.edu.br)

Outubro/ 2017
Estruturas de Controle
Um programa de computador é uma sequência de instruções
organizadas de forma a produzir a solução de um determinado
problema; o que representa uma das habilidades básicas da
programação, que é a sequenciação.

Naturalmente, as instruções de um programa são executadas em

sequência, o que se denomina fluxo sequencial de execução. Mas,
em inúmeras circunstâncias, é necessário executar as instruções
de um programa em uma ordem diferente da estritamente
sequencial.

Tais situações são caracterizadas pela necessidade da repetição de

instruções individuais ou conjuntos de instruções, e também pelo
desvio do fluxo de execução, tarefas que podem ser realizadas
por meio das “estruturas de controle” da linguagem.
Tipos de Estruturas de Controle

a) fluxo b) fluxo c) fluxo

sequencial de execução repetitivo
de execução com desvio de execução

os comandos são os comandos são executados os comandos são executados,

executados um após ao dependendo do valor de de forma repetida, um
outro sequencialmente uma condição, ou expressão determinado número
do início até o lógica: de vezes:
final •if •while
•if else •for
•if elif
Operadores relacionais
relação (ou comparação) de valores:
== igual a
>>> a = 10
!= diferente de >>> b = 20 >>> a <= c
>>> c = 10 True
< menor do que
> maior do que >>> a == c >>> a <= b
True True
<= menor ou igual a
>= maior ou igual a >>> a == b
False
>>> b <= a
False

>>> a > b >>> a != b

False True

>>> b > a >>> a != c

True False
Operadores lógicos (ou booleanos)
not negação lógica
and “e” lógico conjunção
or “ou” lógico disjunção

>>> A = True >>> A and B

>>> B = False False
V = True >>> not A >>> A or B
False True
F = False
>>> not B
True
Estrutura Condicional: if
O if é um comando de desvio “condicional” simples do fluxo de
execução, isto é, capaz de selecionar um entre dois caminhos
distintos para execução, dependendo do resultado, falso ou
verdadeiro, resultante da expressão lógica associada.

if <Expressão lógica (ou codição)>:

comando1
False
comando2 condição
… condição
comandoN
True

comando(s)
Esta primeira forma (simples) de desvio comando(s)
de fluxo permite executar ou não um certo
comando ou conjunto de comandos,
conforme o resultado de uma condição.
Exemplificando as comparações (1/4)
n = int(input("Informe um número inteiro: "))

print()

if (n == 5):
print(n ,"é igual a 5")

if (n != 5):
print(n, "é diferente de 5")

if (n < 5):
print(n, "é menor que 5")

if (n > 5):
print(n, "é maior que 5")

if ((n >= 5) and (n <= 9)):

print(n, "pertence ao intervalo " \
"de 5 até 9.")
Exemplificando as Comparações (2/4)
Representação matemática: Representação computacional:

5 if (n == 5):
n = 5 print(n, "é igual a 5")

5 if (n < 5):
n < 5 print(n, "é menor que 5")

5 if (n <= 5):
n ≤ 5 print(n, "é menor ou igual a 5")

5 if (n > 5):
n > 5 print(n, "é maior que 5")

5 if (n >= 5):
n ≥ 5 print(n, "é maior ou igual a 5")
Exemplificando as Comparações (3/4)
Representação matemática: Representação computacional:

5 if (n != 5):
n # 5 print(n, "é diferente de 5")

5 9 if ((n != 5) and (n != 9)):

n # 5, e n # 9 print(n, "é diferente de 5 " \
"e diferente de 9")

5 9 if ((n == 5) or (n == 9)):
n = 5, ou n = 9 print(n, "é igual a 5 " \
"ou é igual a 9")

5 9 if ((n < 5) or (n > 9)):

n < 5, ou n > 9 print(n, "está fora do intervalo " \
"entre 5 e 9.")
Exemplificando as Comparações (4/4)
Representação matemática: Representação computacional:

Intervalo (sem os extremos):

5 9 if ((n > 5) and (n < 9)):
n > 5, e n < 9 print(n, "pertence ao intervalo " \
"de 5 até 9.")

5 9 if (5 < n < 9):

n > 5, e n < 9 print(n, "pertence ao intervalo " \
"de 5 até 9.")

Intervalo (com os extremos):

5 9 if ((n >= 5) and (n <= 9)):
n ≥ 5, e n ≤ 9 print(n, "pertence ao intervalo " \
"de 5 até 9.")

5 9 if (5 <= n <= 9):

n ≥ 5, e n ≤ 9 print(n, "pertence ao intervalo " \
"de 5 até 9.")
# Verificando se um número inteiro é par ou ímpar.

n = int(input("Informe um número inteiro: "))

print()
False
((n%2) == 0)
((n%2) == 0)

if ((n%2) == 0):
True
print(n, "é um número \"par\"")
print(n, "é um número \"par\"")
print(n, "é um número \"par\"")

if ((n%2) == 1):
print(n, "é um número \"ímpar\"")

False
((n%2) == 1)
((n%2) == 1)

True

print(n, "é um número \"ímpar\"")

print(n, "é um número \"ímpar\"")
a = int(input("Informe o 1o. valor: "))
b = int(input("Informe o 2o. valor: ")) False
(a < b)
(a < b)
print()
True

if (a < b):
print(a, "é menor do que", b)
print(a, "é menor do que", b) print(a, "é menor do que", b)

if (a == b):
print(a, "é igual a", b) False
(a == b)
(a == b)

True
if (a > b):
print(a, "é maior do que", b) print(a, "é igual a", b)
print(a, "é igual a", b)

False
(a
(a >
> b)
b)

True

print(a, "é maior do que", b)

print(a, "é maior do que", b)
Estrutura Condicional: if else
Esta segunda forma (composta) de desvio de fluxo permite que
seja executado o comando1, caso o resultado da expressão
lógica for verdadeiro e no caso do resultado da expressão lógica
for “falso” o “comando2” e que será executado.
if <Expressão lógica (ou lógica)>:
comando1
else:
comando2

False True
condição
condição

comando2
comando2 comando1
comando1
# Verificando se um número inteiro é par ou ímpar.

n = int(input("Informe um número inteiro: "))

print()

if ((n%2) == 0):
print(n, "é um número \"par\"")
else:
print(n, "é um número \"ímpar\"")

False True
((n%2) == 0)
((n%2) == 0)

print(n, "é um número \"ímpar\"") print(n, "é um número \"par\"")

print(n, "é um número \"ímpar\"") print(n, "é um número \"par\"")
a = int(input("Informe o 1o. valor: "))
b = int(input("Informe o 2o. valor: "))

print()

if (a < b):
print(a, "é menor do que", b)
else:
if (a == b):
print(a, "é igual a", b)
else:
print(a, "é maior do que", b)

False True
(a
(a <
< b)
b)

False True print(a, "é menor do que", b)

(a
(a ==
== b)
b) print(a, "é menor do que", b)

print(a, "é maior do que", b) print(a, "é igual a", b)

print(a, "é maior do que", b) print(a, "é igual a", b)
Definir o maior entre 2 (dois) números:
2n-1 = 22-1 = 21 = 2 caminhos na árvore de decisão.
Árvore de decisão: Representação computacional:

a>b if (a > b):

print("O maior valor é", a)
V F else:
print("O maior valor é", b)

a b
Definir o maior entre 3 (três) números:
2n-1 = 23-1 = 22 = 4 caminhos na árvore de decisão.
Árvore de decisão: Representação computacional:

a>b if (a > b):

V F if (a > c):
print("O maior valor é", a)
else:
print("O maior valor é", c)
a>c b>c
else:
V F V F if (b > c):
print("O maior valor é", b)
else:
a c b c print("O maior valor é", c)
 Definir o maior entre 4 (quatro) números:
2n-1 = 24-1 = 23 = 8 caminhos na árvore de decisão.
Árvore de decisão: Representação computacional:
if (a > b):
a>b if (a > c):
if (a > d):
V F
print("O maior valor é", a)
else:
print("O maior valor é", d)
a>c b>c else:
V F V F if (c > d):
print("O maior valor é", c)
else:
a>d c>d b>d c>d print("O maior valor é", d)
else:
V F V F V F V F if (b > c):
if (b > d):
a d c d b d c d print("O maior valor é", b)
else:
print("O maior valor é", d)
else:
if (c > d):
print("O maior valor é", c)
else:
print("O maior valor é", d)
Uso “Aninhado” de if else (1/2)
if (condição1): Neste caso o comando1 é executado quando a
if (condição2): condição1 e a condição2 forem verdadeiras, e o
comando1 “comando2” é executado quando a “condição1
else: for verdadeira e a condição2 for falsa”.
comando2

Isso porque a regra básica é que uma cláusula else sempre pertence ao comando if
imediatamente anterior. O uso da indentação permite modificar esta regra.

if (condição1): Agora o comando1 continua sendo executado

if (condição2): quando a condição1 e a condição2 forem
comando1 verdadeiras, entretanto, o “comando2” é
else: executado, simplesmentes, quando a “condição1
comando2 for falsa”.
Uso “Aninhado” de if else (2/2)
if (condição1):
if (condição2): False
condição1
True
condição1
comando1
else:
False True
comando2 condição2
condição2
Comando 1
Condição 1 e 2- Verdadeiro comando2
comando2
comando1
comando1
Comando 2
Condição 1- Verdadeiro
Condição 2- Falso

if (condição1):
if (condição2): False True
condição1
comando1 condição1

else:
comando2 comando2
False
condição2
True
comando2 condição2

Comando 1
comando1
Condição 1 e 2- Verdadeiro comando1
Comando 2
Condição 1- Falso
Aninhamentos (ou Embutimentos)
Um aninhamento é o fato de se ter qualquer um dos tipos de
construção de comandos dentro de em conjunto de comandos
compostos (if, if else, if elif, for e while).

Regra: A construção mais interna deve estar inteiramente contida

na construção imediatamente mais externa.

Válido Inválido
Estrutura Condicional: if elif (1/3)
A estrutura condicional if elif é um comando que implementa
estruturas condicionas “if else” encadeadas.

Estrutura Condicional: if else Estrutura Condicional: if elif

a = int(input("Informe o 1o. valor: ")) a = int(input("Informe o 1o. valor: "))
b = int(input("Informe o 2o. valor: ")) b = int(input("Informe o 2o. valor: "))

print() print()

if (a < b): if (a < b):

print(a, "é menor do que", b) print(a, "é menor do que", b)
else: elif (a == b):
if (a == b): print(a, "é igual a", b)
print(a, "é igual a", b) else:
else: print(a, "é maior do que", b)
print(a, "é maior do que", b)
Estrutura Condicional: if elif (2/3)
# Definindo o nome de um mês.
mes = int(input("Informe o mês: "))
print()

if (mes == 1):
print("janeiro")
elif (mes == 2):
print("fevereiro")
elif (mes == 3):
print("março")
elif (mes == 4):
print("abril")
elif (mes == 5):
print("maio")
elif (mes == 6):
print("junho")
elif (mes == 7):
print("julho")
elif (mes == 8):
print("agosto")
elif (mes == 9):
print("setembro")
elif (mes == 10):
print("outubro")
elif (mes == 11):
print("novembro")
else:
print("dezembro")
Estrutura Condicional: if elif (3/3)
# Contando as vogais de uma String.
s = input("Informe uma String:\n")
ctA = ctE = ctI = ctO = ctU = 0
for i in range(len(s)):

if ((s[i]=='a') or (s[i]=='A')):
ctA+=1
elif ((s[i]=='e') or (s[i]=='E')):
ctE+=1
elif ((s[i]=='i') or (s[i]=='I')):
ctI+=1
elif ((s[i]=='o') or (s[i]=='O')):
ctO+=1
elif ((s[i]=='u') or (s[i]=='U')):
ctU+=1
s[i] s[i] s[i] s[i] s[i]

print()
print("Vogais A =", ctA) F F F F F
print("Vogais E =", ctE) 'a'or'A' 'e'or'E' 'i'or'I' 'o'or'O' 'u'or'U'
'a'or'A' 'e'or'E' 'i'or'I' 'o'or'O' 'u'or'U'
print("Vogais I =", ctI)
print("Vogais O =", ctO) V V V V V
print("Vogais U =", ctU) ctA+=1 ctE+=1 ctI+=1 ctO+=1 ctU+=1
ctA+=1 ctE+=1 ctI+=1 ctO+=1 ctU+=1
Atribuição Condicional (1/2)
Na atribuição condicional a atribuição de um valor está condicionada ao resultado
de uma expressão lógica (ou condição) da mesma forma como acontece com uma
estrutura condicional “if else”:
<variável> = <ValorSeCondiçãoTrue> if <Condição> else <ValorSeCondiçãoFalse>

# Realizando a difernção do maior valor pelo menor valor.

a = int(input("Informe o 1o. valor: "))
b = int(input("Informe o 2o. valor: "))

diferenca = (a - b) if a >= b else (b - a)

print("|", a, "-", b, "| =", diferenca)

if a >= b:
diferenca = (a – b)
else:
diferenca = (b - a)
Atribuição Condicional (2/2)
# Verificando se um número inteiro é par ou ímpar.
n = int(input("Informe um número inteiro: "))

print()

print(n, "é um número par" if ((n%2)==0) else "é um número ímpar")

if ((n%2)==0):
print(n, "é um número par")
else:
print(n, "é um número ímpar")