Comandos 

Condicionais

Kethllen Andrey Santos

 UFU 

2016

Informática para Biotecnologia

Antes de conhecer as instruções de controle de fluxo, como comandos condicionais ou de repetição, é necessário entender a representação de Yes e No, além de saber como escrevê-los no código em Python.
 

Operadores Lógicos

  • Enquanto os tipos de dados inteiro, ponto flutuante e string têm um número quase ilimitado (depende do tamanho da memória) de valores possíveis, o tipo de dados booleano (homenagem a George Boole) possui apenas dois valores: True e False
  • Quando digitado como código Python, os valores booleanos True e False não tem aspas em torno como as strings e sempre começam com uma letra T ou F maiúscula e o restante da palavra em letras minúsculas
  • Digite no shelll interativo as instruções a seguir levando em conta que algumas podem estar incorretas:

 

Valores booleanos

>>> word = True
>>> word
True
>>> word2 = False
>>> word2
False
>>> 
>>> False
False
>>> 


>>> true
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
>>> 
>>> False = 3 * 4
>>> False
12
>>> True = 4 + 4
>>> True
8
  • Os operadores de comparação comparam dois valores e são avaliados como um único valor booleano. A tabelinha abaixo mostra estes operadores. 

Operadores de comparação

     Operador      Significado
== igual a 
!= diferente de 
< menor que
> maior que
>= menor ou igual a
<= maior ou igual a 
  • Estes operadores são avaliados como True ou False de acordo com os valores fornecidos.

Testando alguns operadores:

Operadores de comparação

>>> #Testando alguns operadores
... 
>>> 1230 = 1230
  File "<stdin>", line 1
SyntaxError: can't assign to literal
>>> 1230 == 1230
True
>>> 
>>> 10.000 == 10.0000
True
>>> 
>>> 10.000 != 10.0000
False
>>> "Casa" == "Casa"
True
>>> "CASA" == "Casa"   # Maiúscula x Minúscula
False

Observe que podemos comparar valores string além de valores inteiros e pontos flutuantes.

Operadores de comparação

>>> 4 > 1.2
True
>>> 
>>> 20.00000001 < 20.00000001
False
>>> 20.00000001 < 20.0000001
True
>>> 2312 <= 2313
True
>>> 2312 >= 2312
True
>>> 2312 >= 2313
False
>>>
  • Os três operadores booleandos (and, or e not) são usados para comparar valores booleanos
  • Assim como os operadores de comparação, eles avaliam essas expressões reduzindo-as a um valor booleano
  • Explorando estes operadores em detalhes.

Operadores booleanos

>>> True
True
>>> 
>>> True and True
True
>>> 
>>> True and False
False
>>> 
>>> False and True
False
>>> 
>>> False and False
False
>>>

Operadores booleanos binários

  • Isto nos permite montar a Tabela da Verdade que mostra os resultados possíveis de um operador booleano

Operadores booleanos

Tabela Verdade (and)

Expressão  Avaliação
True and True True
True and False False
False and True False
False and False False
  • Este é o grande princípio do mundo digital, onde os circuitos eletrônicos normalmente se baseiam em operações com dois dígitos (On ou Off) e partir daí as operações podem ser executadas

Exemplo de circuito eletrônico

Expressão  Avaliação
True or True True
True or False True
False or True True
False or False False

Tabela Verdade (or)

De modo diferente de and e or, o operador not atua somente sobre um valor booleano (ou uma expressão). O operador not simplesmente é avaliado como o valor booleano oposto.

Operadores not

>>> not  True
False
>>> 
>>> not False
True

Podemos aninhar operadores na mesma expressão:

>>> not not True
True
>>> 
>>> not not not True
False

Tabela Verdade do Operador not

Expressão  Avaliação
not True False
not False True
  • Como os operadores de comparação são avaliados como operadores booleanos, podemos usá-los em expressões com operadores booleanos

 

  • Embora expressões como 10 < 1 não sejam valores booleanos, elas são expressões avaliadas como valores booleanos.

 

Operadores de comparação e booleanos numa mesma expressão

>> (10 < 21) and (10 > 2)
True
>>> (10 < 21)
True
>>> 
>>> (10 > 2)
True
>>> 
>>> x = 10
>>> y = 21
>>> z = 2
>>> (x < y) and (x > z)
True

Operadores de comparação e booleanos numa mesma expressão

  • O interpretador avalia inicialmente a expressão à esquerda e, em seguida, avaliará a expressão à direita. Depois de gerar o resultado de cada expressão, compará as duas e reduzirá a um único valor booleano. Isso vale para qualquer quantidade de comparações.
  • Um cuidado deve ser tomado com ordens de prioridade já que podemos ter vários operadores booleanos numa mesma expressão juntamento com os operadores de comparação. Assim como os operadores matemáticos existe uma ordem de atuação.
  • O Python, avalia da seguinte forma:

Monta a expressão True and (10<z)
Atribui a z o valor de 2
Monta a expressão True and (10<2)
Monta a expressão True and True
Resulta em True

Avalia a expressão da esquerda entre parenteses (x<y)
Atribui a x o valor 10
Atribui a y 0 valor 21
Monta a expressão (10 < 21) and (10<z)


>>> x = 10
>>> y = 21
>>> z = 2
>>> (x < y) and (x > z)
True

Execução condicional (if)

  • Já sabemos que o Python permite que instruções sejam processadas de maneira sequencial (algumas linguagens permitem o processamento paralelo)
  • Estas instruções podem ser montadas em expressões mais complexas que segundo uma regra pré-determinada pelo interpretador ou compilador são executadas passo-a-passo
  • A verdadeira eficácia da programação não está somente em executar uma instrução após a outra como uma lista de tarefas do dia-a-dia ou ainda um script de teatro
  • De acordo com o modo como as expressões são avaliadas, o programa pode decidir alterar a sequência descrita no código-fonte (seja no arquivo texto ou no shell script)
  • Ele efetivamente poderá pular instruções, repeti-las ou escolher uma entre várias
  • Para isso temos as instruções de controle de fluxo que poderão decidir quais instruções Python poderão ser executadas de acordo com determinadas condições. Uma forma prática de enxergar estes fluxos é entender o papel dos fluxogramas
  • Eles basicamente contém estruturas de início, processamento, condição, entrada, saída, fluxo de processamento e fim.

Execução condicional  (if)

  • A figura ao lado mostra um fluxograma que calcula o máximo divisor comum entre dois valores
  • Nele podemos ver várias estruturas e entre elas algumas que decidem o controle do fluxo
  • Em um fluxograma, geralmente existe mais de uma maneira de ir do início ao fim
  • O mesmo vale para as linhas de código em um programa de computador
  • Os fluxogramas representam esses pontos de ramificação com losangos, enquanto os demais passos são representados por retângulos
  • Os passos iniciais e finais podem ser representados por retângulos com cantos arredondados.

Execução condicional  (if)

  • Dessa forma, poderemos escrever programas interessantes, podendo checar condições e mudar o comportamento do programa de acordo com elas
  • As instruções condicionais nos dão essa habilidade
  • A forma mais simples é a instrução if (se):
>>> 
>>> numero = input()
11
>>> if(numero>0):
...   print("O número digitado é positivo")
... 
O número digitado é positivo

A expressão booleana depois da instrução if é chamada de condição

Se ela é verdadeira (true), então a instrução indentada é executada

'Se não, nada acontece.

>>> numero = int(input())
-1
>>> if(numero>0):
...   print("O número digitado é positivo.")
... 
>>>

Execução condicional  (if)

  • Assim como outras instruções compostas, a instrução if é constituída de um cabeçalho e de um bloco de instruções:
Cabeçalho:
  Primeiro comando
  ...
  Último comando
  • O cabeçalho começa com uma nova linha e termina com dois pontos (:)
  • Os comandos ou instruções indentados que seguem são chamados de bloco
  • A primeira instrução não indentada marca o fim do bloco
  • Um bloco de comandos dentro de um comando composto ou instrução composta é chamado de corpo do comando
  • Não existe limite para o número de instruções que podem aparecer no corpo de uma instrução if, mas tem que haver pelo menos uma
  • Ocasionalmente, é útil ter um corpo sem nenhuma instrução (usualmente, como um delimitador de espaço para código que você ainda não escreveu)
  • Nesse caso, pode-se usar o comando pass, que indica ao Python: “passe por aqui sem fazer nada”. 

Execução alternativa (else)

  • Um segundo formato da instrução if é a execução alternativa, na qual existem duas possibilidades e a condição determina qual delas será executada. A sintaxe se parece com:
>>> numero = int(input())
10
>>> if(numero%2==0):
...   print("O número digitado é par.")
... else:
...   print("O número digitado é ímpar.")
... 
O número digitado é par.
>>> 
>>> numero = int(input())
11
>>> if(numero%2==0):
...   print("O número digitado é par.")
... else:
...   print("O número digitado é ímpar.")
... 
O número digitado é ímpar.
>>>
  • Se o resto da divisão de x por 2 for 0, então sabemos que x é par, e o programa exibe a mensagem para esta condição. Se a condição é falsa, o segundo grupo de instruções é executado
  • Desde que a condição deva ser verdadeira (True) ou falsa (False), precisamente uma das alternativas vai ser executada. As alternativas são chamadas ramos (branches), porque existem ramificações no fluxo de execução

Condicionais Encadeadas

  • Muitas vezes existem mais de duas possibilidades e precisamos de mais que dois caminhos de execução. Uma condicional encadeada é uma maneira de expressar uma operação dessas:
>>> x = int(input("Digite x: "))
Digite x: 10
>>> y = int(input("Digite y: "))
Digite y: 5
>>> if x < y:
...    print("%d é menor que %d" %(x,y))
... elif x > y:
...    print("%d é maior que %d" %(x,y))
... else:
...    print("%d é igual a %d" %(x,y))
... 
10 é maior que 5

>>> x = int(input("Digite x: "))
Digite x: 1000
>>> y = int(input("Digite y: "))
Digite y: 1001
>>> if x < y:
...    print("%d é menor que %d" %(x,y))
... elif x > y:
...    print("%d é maior que %d" %(x,y))
... else:
...    print("%d é igual a %d" %(x,y))
... 
1000 é menor que 1001
>>> 

>>> x = int(input("Digite x: "))
Digite x: 1000
>>> y = int(input("Digite y: "))
Digite y: 999
>>> if x < y:
...    print("%d é menor que %d" %(x,y))
... elif x > y:
...    print("%d é maior que %d" %(x,y))
... else:
...    print("%d é igual a %d" %(x,y))
... 
1000 é maior que 999
>>>
  • elif é uma abreviação de “else if” (“senão se”)
  • De novo, precisamente um ramo será executado
  • Não existe limite para o número de instruções elif, mas se existir uma instrução else ela tem que vir por último.

Condicionais Encadeadas

  • Considerações:
    • Cada condição é checada na ordem
    • Se a primeira é falsa, a próxima é checada, e assim por diante
    • Se uma delas é verdadeira, o ramo correspondente é executado, e a instrução termina
    • Mesmo que mais de uma condição seja verdadeira, apenas o primeiro ramo verdadeiro executa.
  • Exercício:
    • Desenvolva um código que decida se a nota final digitada aprova, reprova (abaixo de 60) ou permite prova alternativa (entre 45 e 60) para determinado aluno
    • Entrada:
      • Nota final e nome do aluno
    • Saída:
      • "O aluno FULANO está APROVADO." ou
      • "O aluno FULANO poderá fazer PROVA ALTERNATIVA." ou
      • "O aluno FULANO está REPROVADO."

Condicionais Aninhadas

  • Um condicional também pode ser aninhado dentro de outra
  • Poderíamos ter escrito o exemplo tricotômico (dividido em três) como segue:                           
  • O condicional mais externo tem dois ramos:
    • O primeiro ramo contém uma única instrução de saída
    • O segundo ramo contém outra instrução if, que por sua vez tem dois ramos
  • Os dois ramos são ambos instruções de saída, embora pudessem conter instruções condicionais também.

 

>>> x = int(input("Digite x: "))
Digite x: 5
>>> y = int(input("Digite y: "))
Digite y: 10
>>> if x == y:
...    print("%d e %d são iguais" %(x,y))
... else:
...    if x < y:
...       print("%d é menor que %d" %(x,y))
...    else:
...       print("%d é maior que %d" %(x,y))
... 
5 é menor que 10
>>>

 

Embora a indentação das instruções torne a estrutura aparente, condicionais aninhados tornam-se difíceis de ler rapidamente

Em geral, é uma boa ideia evitar o aninhamento quando for possível.

 

Condicionais Aninhadas

  • Operadores lógicos frequentemente fornecem uma maneira de simplificar instruções condicionais aninhadas. Por exemplo, podemos reescrever o código a seguir usando uma única condicional:
>>> x = int(input("Digite o valor de x: "))
Digite o valor de x: 2
>>> if 0 < x:
...   if x < 10:
...     print("X é um número positivo de um só algarismo")
... 
X é um número positivo de um só algarismo
>>>
  • A instrução print é executada somente se a fizermos passar por ambos os condicionais, então, podemos usar um operador and
>>> if 0 < x and x < 10:
...     print("X é um número positivo de um só algarismo")
... 
X é um número positivo de um só algarismo
  • Esses tipos de condições são comuns, assim, Python provê uma sintaxe alternativa que é similar à notação matemática:
>>> if 0 < x < 10:
...     print("X é um número positivo de um só algarismo")
... 
X é um número positivo de um só algarismo

 Return  

  • O comando return permite terminar a execução de uma função antes que ela alcance seu fim
  • Uma razão para usá-lo é se você detectar uma condição de erro
>>> def printLog(x):
...   if x < 0:
...      print("Somente números positivos, por favor.")
...      return 
...   resultado = math.log(x,10)
...   print("O log de %d é %f " %(x,resultado))
... 
>>> printLog(10)
O log de 10 é 1.000000 
>>> printLog(-10)
Somente números positivos, por favor.
>>> printLog(100)
O log de 100 é 2.000000 
>>>

Exercícios

 

  1. Experimente repetir o código calculando o log na base 10 apenas de números positivos maiores que 1.
  2. Desenvolva um código que calcule a raiz quadra de um número levando em conta que a função matemática é sqrt.
  3. Crie um código que receba ângulos em radianos e calcule o seno e o cosseno para valores maiores que zero.
  4. Desenvolva uma função completa para calcular as raízes de uma equação de segundo grau.

“É divertido fazer o impossível, pois lá a concorrência é menor.”

Walt Disney

Made with Slides.com