{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center>Introdução à Lógica de Programação</center>\n",
    "###  <center>Um curso prático para estudantes das Ciências da Vida</center>\n",
    "---\n",
    "## <center>Aula 3. Estruturas Condicionais</center>\n",
    "##### <center>Instrutor: <a href=\"https://pedrosiracusa.github.io\" target=\"_blank\">Pedro C. de Siracusa</a></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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. \n",
    "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.\n",
    "\n",
    "<img src=\"img/ifelse_train.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objetivos. \n",
    "\n",
    "Após esta aula você deverá ser capaz de:\n",
    "* Reconhecer os principais **operadores lógicos** e de **comparação**;\n",
    "* Construir e computar **expressões lógicas**;\n",
    "* Construir **estruturas condicionais**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Expressões lógicas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expressões lógicas são aquelas cuja avaliação resulta em valores do tipo **booleano**: verdadeiro (**True**) ou falso (**False**).\n",
    "Os dois principais tipos de operadores para construir expressões lógicas são:\n",
    "* **operadores de comparação**: permitem comparar os valores de um par de objetos, e retornam `True` caso sejam equivalentes e `False` caso contrário; \n",
    "* **operadores lógicos**: úteis para combinar resultados booleanos obtidos de várias comparações, permitindo construir estruturas de decisão mais complexas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Operador | Descrição |\n",
    "| -------- | --------- |\n",
    "| **Operadores de comparação** | |\n",
    "|    `==`  | `True` se valores de dois operandos são iguais |\n",
    "|    `!=`  | `True` se valores de dois operandos são diferentes |\n",
    "|    `<`  | `True` se valor do operando à esquerda é menor que o da direita |\n",
    "|    `<=`  | `True` se valor do operando à esquerda é menor ou igual ao da direita|\n",
    "|    `>`  | `True` se valor do operando à esquerda é maior que o da direita |\n",
    "|    `>=`  | `True` se valor do operando à esquerda é maior ou igual ao da direita |\n",
    "| **Operadores lógicos**| |\n",
    "|    `and`  | Operador lógico \"E\" |\n",
    "|    `or`  | Operador lógico \"OU\" |\n",
    "|    `not`  |Operador lógico \"NÃO\" |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos escrever algumas expressões lógicas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Operações de comparação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A expressão 5=5 é válida?\n",
    "5==5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A expressão 5=3 é válida?\n",
    "5==3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 5 é diferente de 7?\n",
    "5 != 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 5 é maior ou igual a 5?\n",
    "5 >= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 7 é menor que 10?\n",
    "7 < 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Operações lógicas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P and Q: True\n",
      "P or Q: True\n",
      "not P: False\n",
      "not Q: False\n"
     ]
    }
   ],
   "source": [
    "p = True\n",
    "q = True\n",
    "\n",
    "print(\"P and Q:\", p and q )\n",
    "print(\"P or Q:\", p or q )\n",
    "print(\"not P:\", not p )\n",
    "print(\"not Q:\", not q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P and Q: False\n",
      "P or Q: True\n",
      "not P: False\n",
      "not Q: True\n"
     ]
    }
   ],
   "source": [
    "p = True\n",
    "q = False\n",
    "\n",
    "print(\"P and Q:\", p and q )\n",
    "print(\"P or Q:\", p or q )\n",
    "print(\"not P:\", not p )\n",
    "print(\"not Q:\", not q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P and Q: False\n",
      "P or Q: True\n",
      "not P: True\n",
      "not Q: False\n"
     ]
    }
   ],
   "source": [
    "p = False\n",
    "q = True\n",
    "\n",
    "print(\"P and Q:\", p and q )\n",
    "print(\"P or Q:\", p or q )\n",
    "print(\"not P:\", not p )\n",
    "print(\"not Q:\", not q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P and Q: False\n",
      "P or Q: False\n",
      "not P: True\n",
      "not Q: True\n"
     ]
    }
   ],
   "source": [
    "p = False\n",
    "q = False\n",
    "\n",
    "print(\"P and Q:\", p and q )\n",
    "print(\"P or Q:\", p or q )\n",
    "print(\"not P:\", not p )\n",
    "print(\"not Q:\", not q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and not False and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False and True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Operações lógicas envolvendo comparação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# False and True -> False\n",
    "(4 > 5) and (3==3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# True or False -> True\n",
    "(4 > 5) or (3==3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# not(True or False) -> False\n",
    "not( 4>5 or 3==3 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# True and True and False -> False\n",
    "4<5 and 3==3 and 5>5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# True or True or False -> True\n",
    "4<5 or 3==3 or 5>5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que já sabemos codificar **condições**, podemos de fato construir estruturas condicionais."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Construindo Condicionais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estruturas condicionais podem ter diferentes níveis de complexidade, dependendo do conjunto de condições"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A construção `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/conditionals_if.png\" width=\"400\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Antes de chegar na estrutura condicional (sempre executa)\n",
      "Depois da estrutura condicional (sempre executa)\n"
     ]
    }
   ],
   "source": [
    "cond = False\n",
    "\n",
    "print(\"Antes de chegar na estrutura condicional (sempre executa)\")\n",
    "\n",
    "if cond:\n",
    "    print(\"Executo código A\")\n",
    "  \n",
    "print(\"Depois da estrutura condicional (sempre executa)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A construção `if` `else`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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`).\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/conditionals_ifelse.png\" width=\"400\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Antes de chegar na estrutura condicional (sempre executa)\n",
      "Executo código B\n",
      "Depois da estrutura condicional (sempre executa)\n"
     ]
    }
   ],
   "source": [
    "cond = False\n",
    "\n",
    "print(\"Antes de chegar na estrutura condicional (sempre executa)\")\n",
    "\n",
    "if cond:\n",
    "    print(\"Executo código A\")\n",
    "else:\n",
    "    print(\"Executo código B\")\n",
    "print(\"Depois da estrutura condicional (sempre executa)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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. \n",
    "Mas e se desejarmos construir uma estrutura condicional que permita **mais do que apenas dois \"caminhos\" diferentes**? \n",
    "Neste caso precisamos verificar mais do que uma única condição."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Condicionais aninhadas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "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.\n",
    "\n",
    "**<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!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/conditionals_ifelifelse.png\" width=\"500\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Antes de chegar na estrutura condicional (sempre executa)\n",
      "Executo código C. A cond1 foi False\n",
      "Depois da estrutura condicional (sempre executa)\n"
     ]
    }
   ],
   "source": [
    "cond1 = False\n",
    "cond2 = False\n",
    "\n",
    "print(\"Antes de chegar na estrutura condicional (sempre executa)\")\n",
    "\n",
    "if cond1:\n",
    "    print(\"Executo código A. Não importa a cond2\")\n",
    "else:\n",
    "    if cond2:\n",
    "        print(\"Executo código B. A cond1 foi False\")\n",
    "    else:\n",
    "        print(\"Executo código C. A cond1 foi False\")\n",
    "\n",
    "print(\"Depois da estrutura condicional (sempre executa)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A construção `if` `elif` `else`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Antes de chegar na estrutura condicional (sempre executa)\n",
      "Executo código C. A cond1 foi False\n",
      "Depois da estrutura condicional (sempre executa)\n"
     ]
    }
   ],
   "source": [
    "cond1 = False\n",
    "cond2 = False\n",
    "\n",
    "print(\"Antes de chegar na estrutura condicional (sempre executa)\")\n",
    "\n",
    "if cond1:\n",
    "    print(\"Executo código A. Não importa a cond2\")\n",
    "elif cond2:\n",
    "    print(\"Executo código B. A cond1 foi False\")\n",
    "else:\n",
    "    print(\"Executo código C. A cond1 foi False\")\n",
    "\n",
    "print(\"Depois da estrutura condicional (sempre executa)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 1.** Verifique se as igualdades abaixo são verdadeiras:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(a)** $2 \\times 2.0 = 4$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*2.0==4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(b)** $2 \\times 3 = 5$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*3==5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(c)** $4a + 3 = b$, para $a=3$ e $b=15$ (primeiro declare as variáveis `a` e `b`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=3\n",
    "b=15\n",
    "\n",
    "4*a+3 == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**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$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aprovado! =]\n"
     ]
    }
   ],
   "source": [
    "notaAluno = 5 # insira aqui a nota do aluno\n",
    "\n",
    "if notaAluno >= 5:\n",
    "    print(\"Aprovado! =]\")\n",
    "else:\n",
    "    print(\"Reprovado =(\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**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:\n",
    "\n",
    "$\n",
    "se  \\quad média \\ final \\geq 9 : menção = SS \\\\\n",
    "se \\quad 7 \\leq média \\ final < 9 : menção = MS \\\\ \n",
    "se \\quad 5 \\leq média \\ final < 7 : menção = MM \\\\ \n",
    "se \\quad 3 \\leq média \\ final < 5 : menção = MI \\\\ \n",
    "se \\quad média \\ final < 3 : menção = II \\\\ \n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculaMedia(p1,p2,p3):\n",
    "    return p1*0.2 + p2*0.2 + p3*0.6\n",
    "\n",
    "def calculaMencao( p1,p2,p3 ):\n",
    "    media = calculaMedia(p1,p2,p3)\n",
    "    print(\"Média foi\",media)\n",
    "    \n",
    "    if media >= 9:\n",
    "        return \"SS\"\n",
    "    elif media >= 7:\n",
    "        return \"MS\"\n",
    "    elif media >= 5:\n",
    "        return \"MM\"\n",
    "    elif media >= 3:\n",
    "        return \"MI\"\n",
    "    else:\n",
    "        return \"II\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Média foi 2.8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'II'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculaMencao(3,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Média foi 3.6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'MI'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculaMencao(3,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Média foi 5.4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'MM'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculaMencao(3,3,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Média foi 9.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'SS'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculaMencao(7,8,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**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*.\n",
    "A identificação se dá com base na presença (1) ou ausência (0) de três caracteres: **vascularização**, **sementes** e **flores**. \n",
    "Utilize a tabela abaixo como referência."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Grupo | Vascularização| Sementes| Flores |\n",
    "|--|--|--|--|\n",
    "| Bryophyta | 0 | 0 | 0 |\n",
    "| Pteridophyta | 1| 0 | 0 |\n",
    "| Gymnospermae | 1 | 1 | 0 |\n",
    "| Angiospermae | 1 | 1 | 1 |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gymnospermae\n"
     ]
    }
   ],
   "source": [
    "# Estas variáveis armazenam a presença (1) ou ausência (0) de cada caractere\n",
    "vasc = 1\n",
    "sem = 1\n",
    "flor = 0\n",
    "\n",
    "if vasc==0 and sem==0 and flor==0:\n",
    "    print(\"Bryophyta\")\n",
    "elif vasc==1 and sem==0 and flor==0:\n",
    "    print(\"Pteridophyta\")\n",
    "elif vasc==1 and sem==1 and flor==0:\n",
    "    print(\"Gymnospermae\")\n",
    "elif vasc==1 and sem==1 and flor==1:\n",
    "    print(\"Angiospermae\")\n",
    "else:\n",
    "    print(\"Não há plantas com estas características\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chave(vasc, sem, flor):\n",
    "    if vasc==0 and sem==0 and flor==0:\n",
    "        return \"Bryophyta\"\n",
    "    elif vasc==1 and sem==0 and flor==0:\n",
    "        return \"Pteridophyta\"\n",
    "    elif vasc==1 and sem==1 and flor==0:\n",
    "        return \"Gymnospermae\"\n",
    "    elif vasc==1 and sem==1 and flor==1:\n",
    "        return \"Angiospermae\"\n",
    "    else:\n",
    "        print(\"Não há plantas com estas características\")\n",
    "        return\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bryophyta'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chave(vasc=0, sem=0, flor=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pteridophyta'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chave(vasc=1, sem=0, flor=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Gymnospermae'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chave(vasc=1, sem=1, flor=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Angiospermae'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chave(vasc=1, sem=1, flor=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Não há plantas com estas características\n"
     ]
    }
   ],
   "source": [
    "chave(vasc=0, sem=1, flor=0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}