ACH5531 - Introdução à Computação
Introdução à Python.
Estruturas Condicionais e de Controle. Recursividade.
Prof. Dr. Grzegorz Kowal
E-mail: [email protected]
URL: https://sites.google.com/usp.br/ach5531
Google Meet: https://meet.google.com/utu-ymsc-gqu
1o sem 2020 – quarta-feira, 10h00-11h45 – CB Softwares Especiais 1
Expressões booleanas
Uma expressão booleana é uma expressão qual o resultado é a verdade (True) ou o falso (False), nada mais:
Exemplo 1:
>>> 5 == 5;True
>>> 5 == 0;
False
O exemplo acima usa o operador ==, que compara dois valores e produz True se forem iguais e False se não forem. Em vez de valores, podemos trabalhar com variáveis:
Exemplo 2:
>>> a = b = 5;>>> a == b;
True
>>> b = 0;
>>> a == b;
False
Operadores relacionais
Conjunto de seis operadores relacionais que podem ser usados na avaliação de expressões e em estruturas de decisão.
Operador Nome Exemplo Resultado
== igual a 5 == 5 Verdadeiro
!= diferente de 8 != 5 Verdadeiro
> maior que 3 > 10 Falso
< menor que 5 < 8 Verdadeiro
>= maior ou igual a 5 >= 10 Falso
<= menor ou igual a 5 <= 5 Verdadeiro
Operadores lógicos
Conjunto de três operadores lógicos que podem ser usados na avaliação de expressões e em estruturas de decisão.
Operador Nome Exemplo Resultado
and e 1 > 0 and 1 > 2 Falso
or ou 8 = 5 or 1 > 0 Verdadeiro
not não not 3 > 10 Verdadeiro
A B A e B
F F F
F V F
V F F
V V V
A B A ou B
F F F
F V V
V F V
V V V
A não A
F V
V F
Estrutura de decisão
Em algumas situações não se deseja, necessariamente, que o programa execute todos seus comandos presentes no algoritmo.
Nesse caso, são usadas estruturas que pedem ao computador para tomar uma decisão, optando por um “caminho”.
A decisão, entretanto, não é tomada pelo computador sozinho. O programador o instrui a seguir um “caminho” a partir de testes.
Comando SE é a estrutura básica de decisão. Sua sintaxe é:
se <expressão lógica> então <comando>
ou:
se <expressão lógica> então <comando> senão <comando>;
Execução condicional
Para escrever programas úteis, quase sempre precisamos da capacidade de verificar condições e mudar o comportamento do programa de acordo com elas. Instruções condicionais nos dão esta capacidade. A forma mais simples é a instrução if:
Exemplo 3:
if x > 0:print(‘x é positivo’)
A expressão booleana depois do if é chamada de condição. Se for verdadeira, a instrução endentada é executada. Se não, nada acontece.
Instruções if têm a mesma estrutura que definições de função: um cabeçalho seguido de um corpo endentado. Instruções como essa são chamadas de instruções compostas.
Não há limite para o número de instruções que podem aparecer no corpo, mas deve haver pelo menos uma. Ocasionalmente, é útil ter um corpo sem instruções (normalmente como um espaço reservado para código que ainda não foi escrito). Neste caso, você pode usar a instrução pass, que não faz nada.
Execução alternativa
Uma segunda forma da instrução if é a “execução alternativa”, na qual há duas possibilidades e a condição determina qual será executada. A sintaxe pode ser algo assim:
Exemplo 4:
if x % 2 == 0:print(‘x é par’) else:
print(‘x é ímpar’)
Se o resto quando x for dividido por 2 for 0, então sabemos que x é par e o programa exibe uma mensagem adequada. Se a condição for falsa, o segundo conjunto de instruções é executado. Como a condição deve ser verdadeira ou falsa, exatamente uma das alternativas será executada. As alternativas são chamadas de ramos (branches), porque são ramos no fluxo da execução.
Condicionais escadeadas
Às vezes, há mais de duas possibilidades e precisamos de mais que dois ramos. Esta forma de expressar uma operação de computação é uma condicional encadeada:
Exemplo 5:
if delta < 0:print(‘delta é negativo’) elif delta > 0:
print(‘delta é positivo’) else:
print(‘delta é zero’)
elif é uma abreviatura de “else if”. Novamente, exatamente um ramo será executado. Não há nenhum limite para o número de instruções elif.
Se houver uma cláusula else, ela deve estar no fim, mas não é preciso haver uma. Cada condição é verificada em ordem. Se a primeira for falsa, a próxima é verificada, e assim por diante. Se uma delas for verdadeira, o ramo correspondente é executado e a instrução é encerrada. Mesmo se mais de uma condição for verdade, só o primeiro ramo verdadeiro é executado.
Condicionais aninhadas
Uma condicional também pode ser aninhada dentro de outra.
Poderíamos ter escrito o exemplo na seção anterior desta forma:
Exemplo 6:
if delta == 0:print(‘delta é zero’) else:
if delta > 0:
print(‘delta é positivo’) else:
print(‘delta é negativo’)
A condicional exterior contém dois ramos. O primeiro ramo contém uma instrução simples. O segundo ramo contém outra instrução if, que tem outros dois ramos próprios. Esses dois ramos são instruções simples, embora pudessem ser instruções condicionais também.
Embora a endentação das instruções evidencie a estrutura das condicionais, condicionais aninhadas são difíceis de ler rapidamente. É uma boa ideia evitá-las quando for possível.
Condicionais aninhadas
Operadores lógicos muitas vezes oferecem uma forma de simplificar instruções condicionais aninhadas. Por exemplo, podemos reescrever o seguinte código usando uma única condicional:
Exemplo 7:
if 0 < x:if x < 10:
print(‘x é entre 0 e 10’)
A instrução print só é executada se a colocarmos depois de ambas as condicionais, então podemos obter o mesmo efeito com o operador and:
Exemplo 8:
if 0 < x and x < 10:print(‘x é entre 0 e 10’)
Para este tipo de condição, o Python oferece uma opção mais concisa:
Exemplo 9:
if 0 < x < 10:print(‘x é entre 0 e 10’)
Recursividade
É legal para uma função chamar outra; também é legal para uma função chamar a si própria. Pode não ser óbvio porque isso é uma coisa boa, mas na verdade é uma das coisas mais mágicas que um programa pode fazer. Por exemplo, veja a seguinte função:
Exemplo 10:
def contador(n):if n <= 0:
print(‘Vai!’) else:
print(n)
contador(n-1)
Se n for 0 ou negativo, a palavra “Vai!” é exibida, senão a saída é n e então a função contador é chamada – por si mesma – passando n-1 como argumento.
Uma função que chama a si mesma é dita recursiva; o processo para executá-la é a recursividade.
Programa 1
Escreva um programa que solicite o salário a quem o utilizar e calcule o imposto a ser pago.
● se o salário for negativo ou zero, mostre mensagem de erro
● se o salário for maior que 1000, o imposto é 10%
● se for menor que 1000, o imposto é 5%.
Programa 1
# Imprime o objetivo do programa.
print("Programa calcula imposto baseado no salário.")
# Solicite o usuário o valor do salário.
salario = float(input("Digite seu salário: "))
# Dependendo do salário calcula imposto diferente.
if salario <= 0.0:
print("Salário inválido!") elif salario > 1000.0:
imposto = 0.1 * salario
print("O imposto é ", imposto) else:
imposto = 0.05 * salario
print("O imposto é ", imposto)
Programa 2
Dados coeficientes a, b, e c da equação quadrática, ax² + bx + c = 0,
acha as raízes dela (os valores de x para quais essa equação é
verdadeira). Use estrutura de decisão para separar os três casos.
Use comandos: print(), input(), float(), if, elif, else.
Para calcular a raiz quadrada use expressão d**0.5.
Programa 2
# Imprime o objetivo do programa.
print("Programa acha raízes de equação quadrática: ax²+bx+c=0.")
# Solicite o usuário os valores de a, b, e c.
a = float(input("Digite o coeficiente a = ")) b = float(input("Digite o coeficiente b = ")) c = float(input("Digite o coeficiente c = "))
'''
Calculate a delta:
d = b² - 4ac '''
d = b * b - 4 * a * c
# Dependendo do valor d escolhe o caminho correto.
if d < 0.0:
print("A equação com coeficientes a = ", a, ", b = ", b, ", c = ", c, " não há raízes.") elif d > 0.0:
x1 = 0.5 * (b - d**0.5) / a x2 = 0.5 * (b + d**0.5) / a
print("A equação com coeficientes a = ", a, ", b = ", b, ", c = ", c, " há duas raízes:") print("x1 = ", x1)
print("x2 = ", x2) else:
x1 = 0.5 * b / a
print("A equação com coeficientes a = ", a, ", b = ", b, ", c = ", c, " há uma raiz:") print("x = ", x1)
