#!/usr/bin/env python
# coding: utf-8

# ## <center>Introdução à Lógica de Programação</center>
# ###  <center>Um curso prático para estudantes das Ciências da Vida</center>
# ---
# ## <center>Aula 3. Estruturas Condicionais</center>
# ##### <center>Instrutor: <a href="https://pedrosiracusa.github.io" target="_blank">Pedro C. de Siracusa</a></center>

# Condicionais são estruturas de decisão fundamentais nas linguagens de programação que permitem que um programa altere seu comportamento em tempo de execução, dependendo do estado em que se encontra. 
# Podemos imaginar um programa em execução como um trem viajando sobre um trilho. Algumas bifurcações podem existir ao longo do percurso, e o caminho tomado pelo trem nestes pontos deve ser selecionado através de manivelas de controle. Dependendo da posição em que se encontra a manivela, o trem pode tomar um ou outro caminho, mas nunca seguir nos dois ao mesmo tempo.
# 
# <img src="img/ifelse_train.jpg">

# Estruturas condicionais permitem alterar o fluxo de execução de um programa através da verificação de **condições**, que podem ser codificadas em nosso programa por meio de **expressões lógicas**.

# ### Objetivos. 
# 
# Após esta aula você deverá ser capaz de:
# * Reconhecer os principais **operadores lógicos** e de **comparação**;
# * Construir e computar **expressões lógicas**;
# * Construir **estruturas condicionais**.

# ## 1. Expressões lógicas

# Expressões lógicas são aquelas cuja avaliação resulta em valores do tipo **booleano**: verdadeiro (**True**) ou falso (**False**).
# Os dois principais tipos de operadores para construir expressões lógicas são:
# * **operadores de comparação**: permitem comparar os valores de um par de objetos, e retornam `True` caso sejam equivalentes e `False` caso contrário; 
# * **operadores lógicos**: úteis para combinar resultados booleanos obtidos de várias comparações, permitindo construir estruturas de decisão mais complexas.

# | Operador | Descrição |
# | -------- | --------- |
# | **Operadores de comparação** | |
# |    `==`  | `True` se valores de dois operandos são iguais |
# |    `!=`  | `True` se valores de dois operandos são diferentes |
# |    `<`  | `True` se valor do operando à esquerda é menor que o da direita |
# |    `<=`  | `True` se valor do operando à esquerda é menor ou igual ao da direita|
# |    `>`  | `True` se valor do operando à esquerda é maior que o da direita |
# |    `>=`  | `True` se valor do operando à esquerda é maior ou igual ao da direita |
# | **Operadores lógicos**| |
# |    `and`  | Operador lógico "E" |
# |    `or`  | Operador lógico "OU" |
# |    `not`  |Operador lógico "NÃO" |

# Vamos escrever algumas expressões lógicas.

# In[ ]:





# Agora que já sabemos codificar **condições**, podemos de fato construir estruturas condicionais.

# ## 2. Construindo Condicionais

# Estruturas condicionais podem ter diferentes níveis de complexidade, dependendo do conjunto de condições

# ### A construção `if`

# A construção `if` é a estrutura mais simples de escrevermos um bloco de código $A$ que somente deve ser executado caso uma determinada condição **seja satisfeita** (ou seja, avaliada como `True`). Caso contrário, o código $A$ é simplesmente ignorado.

# <img src="img/conditionals_if.png" width="400">

# In[ ]:





# ### A construção `if` `else`

# Um `if` pode ser associado a um `else`, contendo um bloco de código que é executado casa a condição do `if` **não seja satisfeita** (ou seja, avaliada como `False`).
#  

# <img src="img/conditionals_ifelse.png" width="400">

# In[ ]:





# As duas construções tratadas acima se baseiam na verificação de apenas uma condição, que dependendo de como for avaliada (`True` ou `False`), desencadeia um dentre dois possíveis comportamentos. 
# Mas e se desejarmos construir uma estrutura condicional que permita **mais do que apenas dois "caminhos" diferentes**? 
# Neste caso precisamos verificar mais do que uma única condição.

# ### Condicionais aninhadas

# A primeira forma de incluir mais mais do que uma condição a ser testada na estrutura condicional é por **aninhamento**. Como resultado, teremos uma estrutura hierárquica, em que a execução de uma segunda condição depende do resultado de uma primeira condição. 
# Não há limites para o número de níveis hierárquicos em uma estrutura condicional, apesar de que muitos níveis hierárquicos podem tornar o código mais difícil de entender.
# 
# **<span style="color:red">Cuidado!</span>** Em *Python* é fundamental respeitar o nível de indentação dos blocos de código em cada nível hierárquico!

# <img src="img/conditionals_ifelifelse.png" width="500">

# In[ ]:





# ### A construção `if` `elif` `else`

# Uma sequência de vários `if` e `else` aninhados pode inserir muitos níveis de indentação no código, tornando-o confuso. Para evitar este problema, usamos a construção podemos inserir novas condições a serem verificadas usando a palavra `elif`. Pense no `elif` como uma fusão entre um  `else` e um `if`. O `else` no final captura qualquer caso em que nenhuma das condições anteriores foram satisfeitas.

# In[ ]:





# ---

# ## Exercícios

# **Ex 1.** Verifique se as igualdades abaixo são verdadeiras:

# **(a)** $2 \times 2.0 = 4$

# In[ ]:





# **(b)** $2 \times 3 = 5$

# In[ ]:





# **(c)** $4a + 3 = b$, para $a=3$ e $b=15$ (primeiro declare as variáveis `a` e `b`)

# In[ ]:





# **Ex 2.** Complete o código na célula abaixo para imprimir uma mensagem informando se um aluno foi aprovado ou reprovado em uma disciplina com base em sua nota final. A nota mínima necessária para aprovação é $5$.

# In[ ]:


notaAluno = 0 # insira aqui a nota do aluno

# Complete o código abaixo
if :
    print(" ")
else:
    print(" ")


# **Ex 3.** Construa uma função que calcule a média final e menção dos alunos com base nas notas das três provas (com pesos de 20% para as duas primeiras e 60% para a terceira). Divida o problema em duas etapas. Primeiro, você deverá calcular a média das provas com os devidos pesos. Depois, atribuir a menção conforme a seguinte regra:
# 
# $
# se  \quad média \ final \geq 9 : menção = SS \\
# se \quad 7 \leq média \ final < 9 : menção = MS \\ 
# se \quad 5 \leq média \ final < 7 : menção = MM \\ 
# se \quad 3 \leq média \ final < 5 : menção = MI \\ 
# se \quad média \ final < 3 : menção = II \\ 
# $

# In[ ]:


def calculaMencao( p1,p2,p3 ):
    # seu código aqui
    return


# **Ex 4.** Construa uma pequena **chave dicotômica** para identificar uma determinada planta como membro de um dos principais grupos: *Bryophyta*, *Pteridophyta*, *Gymnospermae* ou *Angiospermae*.
# A identificação se dá com base na presença (1) ou ausência (0) de três caracteres: **vascularização**, **sementes** e **flores**. 
# Utilize a tabela abaixo como referência.

# | Grupo | Vascularização| Sementes| Flores |
# |--|--|--|--|
# | Bryophyta | 0 | 0 | 0 |
# | Pteridophyta | 1| 0 | 0 |
# | Gymnospermae | 1 | 1 | 0 |
# | Angiospermae | 1 | 1 | 1 |
# 

# In[ ]:


# Estas variáveis armazenam a presença (1) ou ausência (0) de cada caractere
vasc = 0
sem = 0
flor = 0

# Seu código aqui


# **Ex 5.** Encapsule o código que você construiu no exercício anterior. Para isso, construa uma função de nome `chave`, que recebe como argumentos cada um dos caracteres e retorna o nome do devido grupo botânico.

# In[ ]:


def chave(vasc, sem, flor):
    # seu código aqui
    return