Aula02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"homesweethome\"></div>\n",
    "<div style=\"width: 100%; text-align: center; color: white; background-color: #222; font-size: 3em; font-weight: 700; padding: .5em .5em .6em .5em; line-height: 1.4em;\">Programação em Python para Iniciantes</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "<div style=\"width: 100%; text-align: center; color: white; background-color: #555; font-size: 2.5em; font-weight: 700; padding: .5em .5em .6em .5em; line-height: 1.4em;\">Unidade 2. Condicionais</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "Nesse momento, você já teve contato com alguns elementos de programação em Python.\n",
    "\n",
    "Você fez alguns programas que trocam mensagens com o usuário e fazem cálculos básicos.\n",
    "\n",
    "Porém, até agora, seus programas não conseguem tomar rumos diferentes de acordo com o que o usuário digita.\n",
    "\n",
    "A estrutura de programação usada para mudar o rumo ou fluxo dum programa é chamada de condicional. \n",
    "\n",
    "As estruturas condicionais permitem executar ou não um conjunto de instruções dependendo do resultado de uma condição.\n",
    "\n",
    "As condições (também chamadas de expressões lógicas) retornam as constantes verdadeiro (**`True`**) ou falso (**`False`**).\n",
    "\n",
    "Nesta aula, você vai aprender como escrever programas Python que usam condicionais para resolver problemas.\n",
    "\n",
    "\n",
    "<span style=\"color: red;\">Lembre-se:  Todas as células são executadas teclando <kbd>SHIFT+ENTER</kbd>. As duas últimas células com código só estão presentes para personalizar a formatação deste _notebook_. </span>\n",
    "\n",
    "\n",
    "# Comparações numéricas\n",
    "\n",
    "Em Python, você pode testar vários tipos de condições. \n",
    "\n",
    "As condições mais simples são as aquelas que comparam números. Por exemplo, a seguinte comparação retorna **`False`** (falso), pois 2 **não é** maior do que 5. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2 > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A condição seguinte é **`True`** (verdadeiro), pois 3 igual a 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "3 >= 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operadores de comparação em Python\n",
    "\n",
    "Na tabela abaixo estão todos os operadores de comparação. \n",
    "\n",
    "| operador | significado      |\n",
    "|:--------:|------------------|\n",
    "|      `>` | maior que        |\n",
    "|      `<` | menor que        |\n",
    "|     `>=` | maior ou igual a |\n",
    "|     `<=` | menor ou igual a |\n",
    "|     `==` | igual a          |\n",
    "|     `!=` | diferente de     |\n",
    "\n",
    "A prioridade desses operadores é menor que a dos operadores numéricos. Isto quer dizer que numa mesma expressão esses últimos são avaliados primeiro. Por exemplo, a comparação 3 + 4 < 8 - 1 é equivalente a (3 + 4) < (8 - 1 ). Seu valor é **`False`** pois 7 **não é** menor do que 7.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Faça você mesmo:\n",
    "\n",
    "Os resultados a seguir são todos **`False`**. Mude <b>somente</b> os números para que virem todos **`True`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "4-1 <= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "3.5/3 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 3\n",
    "2**x != 4*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 4\n",
    "y = 2\n",
    "x / 2 != y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x % 2 == y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red;\"><b>Atenção:</b></span>  não confunda o operador de comparação de igualdade `==` com a atribuição `=`.\n",
    "\n",
    "Execute as células abaixo e veja a diferença."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x+3 = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x+3 == 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os operadores de comparação também podem ser usados para comparar outros tipos de dados, por exemplo as cadeias. As cadeias são comparadas usando a ordem lexicográfica (análoga à ordem das palavras em um dicionário). Isso significa comparar os caracteres na mesma posição de esquerda à direita até achar o primeiro diferente. Por exemplo, na ordem lexicográfica `\"Python\" > \"Java\"`. \n",
    "\n",
    "Para que duas cadeias sejam lexicograficamente iguais, cada caracter deve comparar igual e ambas devem ter o mesmo comprimento. Quando uma cadeia é prefixo próprio da outra, a cadeia mais curta é lexicograficamente menor que a mais longa. Por exemplo, `\"amor\" < \"amortecedor\"`.\n",
    "\n",
    "Execute as células abaixo e veja qual comparação é falsa. Mude **somente**\n",
    "as cadeias para que todas as comparações virem **`False`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"1\" == \"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"1\" == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"01\" < \"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"100\" > \"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"avião\" <= \"carro\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"livro\" > \"livraria\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparar valores de tipos diferentes pode gerar resultados inesperados. Veja abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"0\" < 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Valores verdadeiro e falso\n",
    "\n",
    "Ao executar os exemplos da seção acima, você percebeu que o resultado de uma comparação é sempre **`True`** ou **`False`**. Estes são dois valores especiais em Python.\n",
    "\n",
    "Você pode guardá-los em uma variável, se precisar. Veja os exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "teste1 = 3 < 8 / 3\n",
    "print(teste1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "teste2 = True == False\n",
    "print(teste2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "teste3 = 8 < 3\n",
    "print(teste3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Condicionais\n",
    "\n",
    "Agora vamos ver como fazer o Python executar partes de um código somente no caso em que uma condição é verdadeira.\n",
    "\n",
    "Para isso, vamos usar o comando **`if`**, que significa \"se\" em inglês. \n",
    "\n",
    "Veja o exemplo abaixo, execute-o e depois veja a explicação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = 2\n",
    "B = 10\n",
    "if A > B: \n",
    "    print(\"A =\", A, \" é maior que B = \", B)\n",
    "    print(\"===============\")\n",
    "print(\"fim do programa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que as duas linhas `print(...)` logo após o comando **`if`** não surtiram efeito, pois `A > B` é falso para os valores atribuídos a `A` e `B`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Faça você mesmo:\n",
    "\n",
    "<ol>\n",
    "<li>No código acima, mude o valor de `A` para qualquer coisa maior do que 10, re-execute a célula e veja o que acontece.</li>\n",
    "<li>Depois disso, mude o código acima para que `A` e `B` sejam inteiros digitados pelo usuário. </li>\n",
    "<li>Depois disso, mude o código para que `A` e `B` sejam cadeias digitadas pelo usuário. </li>\n",
    "</ol>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estrutura do comando **`if`**\n",
    "\n",
    "O comando **`if`** tem a seguinte estrutura.\n",
    "\n",
    "    if condição:\n",
    "        código  \n",
    "        código\n",
    "        código\n",
    "        etc...\n",
    "    continuação do programa\n",
    "    \n",
    "Todo código que você quiser executar quando a condição for verdadeira devem vir *indentado* (alinhado um pouco mais a frente do que o **`if`**) logo após o comando **`if`**.\n",
    "\n",
    "Você pode usar `TAB` ou `Space` (quatro espaços) para alinhar as linhas. Todas as instruções dentro do **`if`** devem ter a mesma indentação.\n",
    "\n",
    "A linha sem *indentação* (i.e. alinhada com o **`if`**) após esse bloco de comandos é a marca do fim do bloco.\n",
    "\n",
    "\n",
    "<span style=\"color: red;\"><b>Atenção:</b></span>  É uma prática comum em programação fazer indentação de código para que ele fique mais legível. Em muitas linguagens de programação (por exemplo Pascal, C, Java, JavaScript)  a indentação tem um propósito puramente estético pois outros elementos definem o início e o fim dum bloco de várias instruções (`begin ... end`, `{...}`). \n",
    "\n",
    "Em Python a indentação é **obrigatória** para definir as instruções que compoem um bloco. Se você não *indentar* o código corretamente, o programa terá um comportamento diferente daquele que você espera.\n",
    "\n",
    "Por exemplo, execute as células a seguir e veja as mensagens de erro por falta de indentação erro)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = 2\n",
    "B = 10\n",
    "if A > B:\n",
    "print(\"A =\", A, \" é maior que B = \", B)\n",
    "print(\"===============\")\n",
    "print(\"fim do programa\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = 2\n",
    "B = 10\n",
    "if A > B:\n",
    "    print(\"A =\", A, \" é maior que B = \", B)\n",
    "   print(\"===============\")\n",
    "print(\"fim do programa\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = 2\n",
    "B = 10\n",
    "if A > B:\n",
    "    print(\"A =\", A, \" é maior que B = \", B)\n",
    "print(\"===============\")\n",
    " print(\"fim do programa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O código a seguir sempre imprime os =============== pois eles já estão *fora* do bloco do **`if`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = 2\n",
    "B = 10\n",
    "if A > B:\n",
    "    print(\"A =\", A, \" é maior que B = \", B)\n",
    "print(\"===============\")\n",
    "print(\"fim do programa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: idade par\n",
    "\n",
    "Complete o código a seguir de modo que ele tenha o seguinte comportamento:\n",
    "1. Pergunta ao usuário quantos anos ele tem. \n",
    "\n",
    "2. Se o usuário tem idade par, mostra uma mensagem a ele informando-o desse fato. No caso ímpar você não precisa fazer nada.\n",
    "\n",
    "*Dica:* Lembre-se que o operador  `%`  é o operador de resto, ou seja `x % y` é o resto da divisão de `x` por `y`. Se `x % 2` vale zero, então `x` é par, pois não há resto na divisão de `x` por 2.\n",
    "\n",
    "<!-- **No Tidia, responda à *Questão 1* da seção *Unidade 5 - Tutorial*.** -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# o que escrevemos depois de'#' não é executado\n",
    "# isto é chamado de comentário e nos ajuda a entender o código!\n",
    "idade = int(input(\"Quantos anos você tem? \")) # entrada de dados\n",
    "if : # coloque a condição antes dos \":\"\n",
    "    print(\"Sua idade é par.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: menor de idade\n",
    "\n",
    "Complete o código a seguir de modo que ele tenha o seguinte comportamento:\n",
    "\n",
    "1. Pergunta ao usuário em que ano ele nasceu.\n",
    "\n",
    "2. Pergunta ao usuário em que ano estamos.\n",
    "\n",
    "3. Se o usuário for menor de idade (você pode assumir que ele já fez aniversário no ano atual), então o seu programa mostra uma mensagem falando isso. Caso contrário, ele não mostra nenhnuma mensagem.\n",
    "\n",
    "<!-- **No Tidia, responda à *Questão 2* da seção *Unidade 5 - Tutorial*.** -->\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nascimento = int(input(\"Em que ano você nasceu? \"))\n",
    "atual = int(input(\"Em que ano estamos? \"))\n",
    "if : #coloque a condição antes dos \":\"\n",
    "    print(\"Você é menor de idade\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# O comando **`if..else`**\n",
    "\n",
    "Agora que você já entendeu o funcionamento do **`if`**, vamos aprender como executar uma ação (ou várias ações) caso a condição do **`if`** seja falsa. \n",
    "\n",
    "Por exemplo, no exercício da idade par ou impar, se quiséssemos mostrar uma mensagem ao usuário também no caso ímpar, teríamos de fazer algo do tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "idade=int(input(\"Quantos anos você tem? \"))\n",
    "if idade % 2 == 0:\n",
    "    print(\"Sua idade é par.\")\n",
    "if not idade % 2 == 0:         # ou if idade % 2 == 1:\n",
    "    print(\"Sua idade é ímpar.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com o comando **`else`** (que significa \"senão\" em inglês), é possível economizar um pouco de código. Veja o exemplo abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "idade=int(input(\"Quantos anos você tem? \"))\n",
    "if idade % 2 == 0:\n",
    "    print(\"Sua idade é par.\")\n",
    "else:\n",
    "    print(\"Sua idade é ímpar.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou seja, o código no bloco do **`else`** só é executado se a condição do **`if`** for falsa. O segundo programa é mais eficiente que o primeiro pois somente uma condição será testada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Faça você mesmo:\n",
    "\n",
    "Modifique o seu código para o exercício anterior usando **`if..else`** de modo que, se o usuário for maior de idade, ele mostre uma mensagem ao usuário dizendo isso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: aprovado/reprovado\n",
    "\n",
    "Profa. Alice ministra a disciplina de Fenômenos Quânticos na UFABC. Ela dará duas provas ($P1$ e $P2$), e o critério de aprovação é ter média maior ou igual a $5.0$. Faça um programa em Python que ajude a Profa. Alice a decidir se um aluno foi aprovado ou não. Seu programa deve executar os seguintes passos:\n",
    "* Perguntar a nota da $P1$.\n",
    "* Perguntar a nota da $P2$.\n",
    "* Calcular a média das provas.\n",
    "* Se a média das provas for maior ou igual a $5.0$, mostrar a mensagem \"Aprovado\" senão, mostrar \"Reprovado\".\n",
    "\n",
    "<!-- **No Tidia, responda à *Questão 3* da seção *Unidade 5 - Tutorial*.** -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: cerca do fazendeiro\n",
    "\n",
    "Um fazendeiro tem $M$ metros de cerca. Ele quer cercar um terreno retangular de comprimento $C$ e largura $L$. Faça um programa que ajude o fazendeiro a saber se a cerca que ele tem é suficiente ou não. Seu programa deve executar os seguintes passos:\n",
    "* Pergunte a quantidade $M$ (em metros) de cerca disponível.\n",
    "* Pergunte o comprimento $C$ do terreno.\n",
    "* Pergunte a largura $L$ do terreno.\n",
    "* Calcule a quantidade exata (em metros) de cerca que serão necessários para cercar o perímetro do terreno. (O perímetro é a soma dos comprimentos dos 4 lados do terreno). \n",
    "* Baseando-se nesse cálculo, diga ao fazendeiro se a quantidade de cerca que ele tem é ou não é suficiente. \n",
    "\n",
    "<!-- ## No Tidia, responda à *Questão 4* da seção *Unidade 5 - Tutorial*. -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>:  peso ideal\n",
    "\n",
    "Tendo como dados de entrada a altura em metros e o sexo de uma pessoa (`\"F\"` ou `\"M\"`), escreva um programa que imprima seu peso ideal, utilizando as seguintes fórmulas:\n",
    "\n",
    "Para homens: $72.7 * altura - 58$\n",
    "\n",
    "Para mulheres: $62.1 * altura - 44.7$\n",
    "\n",
    "\n",
    "Após isso, o programa deve ler o peso atual da pessoa e imprimir uma mensagem caso a pessoa estiver acima do peso ideal. Use dois  **`if`** consecutivos.\n",
    "\n",
    "Lembre-se: M é uma variável enquanto `\"M\"` é uma constante de cadeia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combinando condições\n",
    "\n",
    "Podemos criar condições mais complexas combinando condições simples. Vejamos um exemplo.\n",
    "\n",
    "Em algumas disciplinas da UFABC, não basta que a média das duas provas ($P1$ e $P2$) de um aluno seja maior ou igual a $5.0$, mas ele também deve tirar uma nota mínima $3.0$ na $P2$. \n",
    "\n",
    "Ou seja, para que seja aprovado o aluno precisa de \n",
    "\n",
    "$$\\frac{P1 + P2}{2} \\geq 5 \\quad\\quad\\text{ E }\\quad\\quad P2 \\geq 3.$$\n",
    "\n",
    "Em Python, podemos usar **`and`** para exigir que duas condições sejam verdadeiras ao mesmo tempo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "P1 = float(input(\"Qual a nota da P1? \")) #convertendo para float, a nota pode ser um número real\n",
    "P2 = float(input(\"Qual a nota da P2? \"))\n",
    "if (P1 + P2) / 2 >= 5.0 and P2 >= 3.0:\n",
    "    print(\"Estudante aprovado\")\n",
    "else:\n",
    "    print(\"Estudante reprovado\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O operador **`and`** funciona assim: a condição composta `(condição1 and condição2)` é avaliada como **`True`** (verdadeira) só quando a `condição1` é **`True`** e, simultaneamente, a `condição2` também é **`True`**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Faça você mesmo:\n",
    "\n",
    "<ol>\n",
    "<li>Modifique o código acima para que a nota da P1 também tenha que ser pelo menos 3.</li>\n",
    "<li>No código abaixo, tente alterar o valor das variáveis `chuva` e `sol` para ver como isso afeta o programa.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "chuva = True\n",
    "sol = False\n",
    "arcoiris = chuva and sol\n",
    "print(arcoiris)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>:  aposentadoria de professores\n",
    "\n",
    "Um professor universitário federal pode se aposentar desde que tenha pelo menos 35 anos de serviço e pelo menos 60 anos de idade. Faça um programa para ajudar o professor a descobrir se ele já pode se aposentar este ano. \n",
    "\n",
    "Seu programa deve fazer o seguinte:\n",
    "* Pergunte ao professor pelo ano em que nasceu.\n",
    "* Pergunte pelo ano em que começou a trabalhar.\n",
    "* Pergunte ao professor pelo ano em que estamos.\n",
    "* Baseando-se nas respostas que ele deu ao seu programa, diga se ele pode se aposentar este ano.\n",
    "\n",
    "<!-- ## No Tidia, responda à *Questão 5* da seção *Unidade 5 - Tutorial*. -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outros operadores lógicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python tem mais dois operadores lógicos: **`not`** (negação) e **`or`** (disjunção). \n",
    "\n",
    "O operador **`not`** pode ser usado para inverter o resultado de uma condição. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "not 2 > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma condição da forma `(condição1 or condição2)` será verdadeira se pelo menos uma das duas condições envolvidas for verdadeira. \n",
    "\n",
    "Diferentemente do que estamos acostumados em português, o operador **`or`** não é um ou-exclusivo, ou seja, se as duas condições `condição1` e `condição2` forem ambas verdadeiras, então o resultado de `(condição1 or condição2)` será verdadeiro. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Faça você mesmo\n",
    "\n",
    "No código abaixo, tente alterar o valor das variáveis `chuva` e `sol` para ver como isso afeta o programa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "frio = True\n",
    "chuva = True\n",
    "tempoRuim = frio or chuva\n",
    "print(tempoRuim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja mais exemplos:\n",
    "o resultado da condição composta abaixo é **`True`** porque, apesar da primeira condição ser falsa, a segunda é verdadeira."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2 > 5 or 1 < 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No próximo exemplo, as duas condições são verdadeiras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "4 == 2 + 2 or 2 > 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: vogais\n",
    "\n",
    "Escreva um programa que dada uma letra determine se é ou não uma vogal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Condicionais aninhadas\n",
    "\n",
    "As condicionais podem estar aninhadas, i.e. uma condicional pode ser uma das instruções do bloco **`if`** ou **`else`**.\n",
    "\n",
    "Por exemplo, o seguinte programa é uma variante melhorada do exemplo acima. Nesta variante, estamos validando as notas lidas. Note-se que estamos usando dois **`if`** aninhados e a indentação deles vai aumentando.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "P1 = float(input(\"Qual a nota da P1? \"))                    #  convertendo para float, a nota pode ser um número quebrado\n",
    "if P1 < 0 or P1 > 10:                                       # validando a entrada\n",
    "    print(\"A nota deve ser um valor entre zero e dez\")\n",
    "else:\n",
    "    P2 = float(input(\"Qual a nota da P2? \"))\n",
    "    if P2 < 0 or P2 > 10:                                   # if aninhado\n",
    "        print(\"A nota deve ser um valor entre zero e dez\")\n",
    "    else:\n",
    "        media = (P1 + P2) / 2                               # calculando a média\n",
    "        if media >= 5.0 and P2 >= 3.0:                      # mais um if aninhado\n",
    "            print(\"Estudante aprovado\")\n",
    "        else:\n",
    "            print(\"Estudante reprovado\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>:  peso ideal com validação\n",
    "\n",
    "Modifique seu programa sobre o peso ideal para validar os dados de entrada e mostrar mensagens de erro apropriadas. Evite ler dados e fazer cálculos desnecessários. Tome cuidado com a indentação.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mais sobre a avaliação de condições\n",
    "\n",
    "Os operadores lógicos **`and`** e **`or`** são avaliados em corto-circuito, i.e.  eles apenas avaliam o segundo argumento se for necessário. Veja o exemplo abaixo. Além disso,  você pode combinar mais de duas condições lógicas, por exemplo:\n",
    "\n",
    "    condição1 and not condição2 or condição3\n",
    "    \n",
    "A tabela abaixo mostra os operadores lógicos e sua avalição em ordem ascendente de prioridade.\n",
    "\n",
    "\n",
    "|  operador  | resultado                           |\n",
    "|:----------:|-------------------------------------|  \n",
    "|   x or  y  | se x é False então y senão x        |\n",
    "|   x and y  | se x é False então x senão y        |\n",
    "|   not x    | se x é False então True senão False |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>:  Faça você mesmo:\n",
    "\n",
    "<ol>\n",
    "<li> Execute o código abaixo </li>\n",
    "<li> Modifique a constante e/ou o operador na atribuição para imprimir Hello World.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "########################\n",
    "def f1(): \n",
    "    # Isto é uma função auxiliar para ilustrar o corto-circuito.\n",
    "    # Não se preocupe, você vai aprender sobre funções em próximas aulas\n",
    "    # A função tem valor True e imprime a cadeia Hello\n",
    "    # O prefixo end= após o print pode ser usado para evitar a nova linha após a saída\n",
    "    print(end=\"Hello \") \n",
    "    return True\n",
    "########################\n",
    "\n",
    "teste1 = True or f1()\n",
    "print(\"World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifique a atribuição abaixo para imprimir Hello Hello Hello usando</li>\n",
    "<ol>\n",
    "<li> somente **`or`** e **`not`** </li>\n",
    "<li> somente **`and`**</li>\n",
    "<li> os três operadores lógicos </li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "teste1 = False or f1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferentemente de outras linguagens, em Python as comparações também podem ser encadeadas arbitrariamente. Desta forma, podemos escrever por exemplo, x < y <= z que é equivalente a x < y **`and`** y <= z, exceto que y é avaliado apenas uma vez (mas em ambos os casos z não é avaliado se x < y é falso).\n",
    "\n",
    "Por exemplo, mude as constantes ou os operadores abaixo para o resultado ser **`False`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2 <= 3 < 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"arroz\" > \"agua\" < \"azeite\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante saber que:\n",
    "\n",
    "<ol>\n",
    "<li> O operador **`not`** tem uma prioridade menor do que os operadores não lógicos. Portanto, **`not`** a == b é avaliado como **`not`** (a == b). Por outro lado, a == **`not`** b é um erro de sintaxe.</li>\n",
    "<li> Como em outras linguagens, em Python qualquer valor diferente 0 é considerado como verdadeiro enquanto 0 é considerado falso. Por isso, o valor da condição **`not 2`** é **`False`** enquanto  **`not 0`** é **`True`**.</li>\n",
    "<li> É necessário ter cuidado ao escrever condições muito longas ou complexas pois podemos obter resultados não esperados. Sempre que precisar, use parênteses ou variáveis auxiliares para garantir o resultado correto.</li>\n",
    "</ol>\n",
    "\n",
    "Veja abaixo alguns exemplos.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "3 > not 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "3 > (not 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "not 3 <= 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "3 > not 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "3 > (not 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = 5\n",
    "(not x > y) == (x <= y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(not x > y) == x <= y    # equivalente a: ( ( not (2 > 5) ) == 2 ) and ( 2 <= 5 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not x > y == x <= y      # equivalente a: not ( ( 2 > 5 ) and ( 5 == 2 ) and ( 2 <= 5 ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(not x) > y == (x <= y)  # equivalente a: ( not ( 2 ) > 5 ) and ( 5 == 2 ) and ( 2 <= 5 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Condicionais encadeadas\n",
    "\n",
    "\n",
    "É bastante comum lidarmos com situações em que o comportamento desejado do programa não depende de apenas uma condição, mas de várias. Vamos ver um exemplo. \n",
    "\n",
    "Suponha que temos que criar um programa para classificar o nível do *low-density lipoprotein* (LDL), conhecido em português com o nome de colesterol \"ruim\". Segundo um [estudo do *NIH*](http://www.nhlbi.nih.gov/files/docs/guidelines/atp3xsum.pdf) citado pelo [*CDC*](http://www.cdc.gov/dhdsp/data_statistics/fact_sheets/fs_cholesterol.htm) Norte Americano, os níveis de LDL podem ser classificados segundo a tabela abaixo.\n",
    "\n",
    "|    Nível de LDL | Classificação |\n",
    "|----------------:|---------------|\n",
    "|   menor que 100 | Ótimo         |\n",
    "| entre 100 e 129 | Baixo         |\n",
    "| entre 130 e 159 | Limítrofe     |\n",
    "| entre 160 e 189 | Alto          |\n",
    "|   maior que 190 | Muito alto    |\n",
    "\n",
    "Se tivéssemos que fazer um programa que perguntasse pelo nível de LDL e que mostrasse a classificação correspondente, poderíamos usar os conhecimentos de **`if..else`** que adquirimos até agora e construir o seguinte programa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "LDL = float(input(\"Qual o nível de LDL? \"))      #convertendo para float\n",
    "print(end=\"Seu nível está: \")\n",
    "if LDL < 100:\n",
    "    print(\"Ótimo\")\n",
    "if 100 <= LDL < 130:\n",
    "    print(\"Baixo\")\n",
    "if 130 <= LDL < 160:\n",
    "    print(\"Limítrofe\")\n",
    "if 160 <= LDL < 190:\n",
    "    print(\"Alto\")\n",
    "if 190 <= LDL:\n",
    "    print(\"Muito alto\")\n",
    "print(\"fim do programa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O programa acima está correto. A maioria das linguagens de programação possuem um comando com sabor de \"senão, se\". O nome desse comando, em Python, é **`elif`** (abreviação de \"else if\"). \n",
    "\n",
    "Você pode usar diversos comandos **`elif`**, mas eles devem sempre vir atrelados a um comando **`if`**. \n",
    "\n",
    "Veja como é mais simples classificar os níveis de LDL com o comando **`elif`**. \n",
    "\n",
    "Ao lado você pode ver o significado de cada linha e, depois do programa, uma explicação mais detalhada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "LDL = float(input(\"Qual o nível de LDL? \"))         # pergunta pelo nível de LDL\n",
    "print(end=\"Seu nível está: \")\n",
    "if LDL < 100:                                       # se nível < 100:\n",
    "    print(\"Ótimo\")                                  #     mostra \"Ótimo\"\n",
    "elif LDL < 130:                                     # senão, se nível < 130: \n",
    "    print(\"Baixo\")                                  #     mostra \"Baixo\"\n",
    "elif LDL < 160:                                     # senão, se nível < 160:\n",
    "    print(\"Limítrofe\")                              #     mostra \"Limítrofe\"\n",
    "elif LDL < 190:                                     # senão, se nível < 190:\n",
    "    print(\"Alto\")                                   #     mostra \"Alto\"\n",
    "else:                                               # senão:  \n",
    "    print(\"Muito alto\")                             #     mostra \"Muito alto\"\n",
    "print(\"fim do programa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No programa acima, o trecho `print(\"Alto\")` só será executado se:\n",
    "* a condição do **`if`** for falsa (isto é, se LDL >= 100) e\n",
    "* a condição do primeiro **`elif`** for falsa (isto é, se LDL >= 130) e\n",
    "* a condição do segundo **`elif`** for falsa (isto é, se LDL >= 160) e\n",
    "* a condição do terceiro **`elif`** for verdadeira (isto é, se LDL < 190).\n",
    "\n",
    "Mais em geral, um trecho de código dentro de um bloco **`elif`** só será executado se <u>a condição daquele **`elif`** for verdadeira, mas todas as condições dos **`elif`** que o precedem, incluindo a condição do **`if`**, forem todas falsas.</u> Além disso, nenhuma das condições seguintes será testada e nenhum outro bloco será executado.\n",
    "\n",
    "Por fim, fique sabendo que usar um comando **`elif`** dentro de um **`if`** não proíbe você de usar um **`else`** também, desde que o **`else`** venha por último. \n",
    "\n",
    "O trecho de código dentro do **`else`** só será executado se <u>**todas**</u> as condições que o precederam forem falsas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: índice de massa corporal\n",
    "\n",
    "Se uma pessoa tem peso $P$ em quilogramas e altura $A$ em metros, o índice de massa corporal (*IMC*) dessa pessoa é\n",
    "$$IMC = \\frac{P}{A^2}.$$\n",
    "\n",
    "Faça um programa que pede para o usuário digitar a sua altura e depois o seu peso. Calcule e mostre\n",
    "o IMC do usuário e diga em que categoria ele está. Use a abaixo tabela. Valide o peso e altura lidos.\n",
    "\n",
    "| Faixa                | Categoria      |\n",
    "|---------------------:|----------------|\n",
    "|           IMC < 18.5 | Abaixo do peso |\n",
    "| 18.5 &le; IMC < 25.0 | Normal         |\n",
    "| 25.0 &le; IMC < 30.0 | Sobrepeso      |\n",
    "|          30 &le; IMC | Obeso          |\n",
    "\n",
    "<!-- No Tidia, responda à *Questão 6* da seção *Unidade 5 - Tutorial*. -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estilo de codificação\n",
    "\n",
    "Agora que você está prestes a escrever código Python mais longo e complexo, é um bom momento para falar sobre o estilo de codificação. Fazer com que seja fácil para outros ler seus programas é sempre bom e para isso é importante usar um estilo de codificação agradável. Algumas regras simples são as seguintes:\n",
    "\n",
    "* Use 4 espaços para a indentação dos blocos pois permite uma maior profundidade no aninhamento e é mais fácil para ler.\n",
    "\n",
    "* Evite linhas que excedam 79 caracteres.\n",
    "\n",
    "* Use linhas em branco para separar funções e blocos de código dentro de funções.\n",
    "\n",
    "* Sempre que possível, coloque comentários \n",
    "\n",
    "* Use espaços em torno de operadores e após vírgulas, e.g. a = f (1, 2) + g (3, 4).\n",
    "\n",
    "* Não utilize caracteres não-ASCII (e.g. letras acentuadas e a cedilha) para nomes de variáveis e funções."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercícios para casa\n",
    "\n",
    "Tente resolver o maior número de exercícios possível. Leve suas respostas na próxima aula para tirar dúvidas com os professores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: de carro ou de ônibus\n",
    "\n",
    "Alice tem um carro que faz 10 km para cada litro de gasolina.\n",
    "\n",
    "Ela quer ir para a UFABC e ela quer decidir se vai de carro ou de ônibus. \n",
    "\n",
    "Como ela quer economizar dinheiro, ela quer saber qual é a opção mais barata.\n",
    "\n",
    "O ônibus custa R$ 3.80, mas o preço da gasolina varia bastante.\n",
    "\n",
    "Faça um programa que:\n",
    "* Pede para Alice digitar o preço da gasolina por litro (ela vai digitar um número float).\n",
    "* Pede para Alice digitar a distância de sua casa para à UFABC .\n",
    "* Calcula o gasto para ir de carro.\n",
    "* Mostra na tela qual é a opção mais barata e o quanto ela economizaria com essa opção. Se der empate, ela vai de carro.\n",
    "\n",
    "Exemplos:\n",
    "* Se o preço da gasolina é 3.50 reais e a casa de Alice fica a 10 km da universidade, então ela gastaria 3.50 reais para ir para a universidade de carro. Portanto, ela economiza 0.30 indo de carro.\n",
    "* Se o preço da gasolina é 4.00 reais e a casa de Alice fica a 9.5 km da universidade, então ela gastaria 3.80 reais para ir para a universidade de carro. Portanto, dá empate e ela vai de carro.\n",
    "* Se o preço da gasolina é 3.50 reais e a casa de Alice fica a 20 km da universidade, então ela gastaria 7.00 reais para ir para a universidade de carro. Portanto, ela economiza 3.20 indo de ônibus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: aumento salarial\n",
    "\n",
    "Escreva um programa para calcular o aumento salarial dum funcionário usando a seguinte regra:\n",
    "\n",
    "* se 1.500,00 <= salarioAtual < 1.750,00: aumento igual a 12%\n",
    "* se 1.750,00 <= salarioAtual < 2.000,00: aumento igual a 10%\n",
    "* se 2.000,00 <= salarioAtual < 3.000,00: aumento igual a 7%\n",
    "* acima de 3.000,00: aumento igual a 5%. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: ordenar três números\n",
    "\n",
    "Escreva um programa que dados três números imprima eles em ordem não decrecescente. Por exemplo, para a entrada 2, 5, 2 a saída deve ser 2, 2, 5. Para a entrada 15, 6, 8 a saída deve ser 6, 8, 15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: comparar quatro números\n",
    "\n",
    "Escreva um programa que dados quatros números reais determine o menor deles. Tente usar o menor número de condicionais possível."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: comparar horas\n",
    "\n",
    "Complete o seguinte programa para dadas duas horas no formato hh:mm:ss determinar qual é menor. Seu programa deve validar que os dados lidos sejam corretos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Entrada duma hora no formato hh:mm:ss\n",
    "hora = input(\"Qual a primeira hora? \")\n",
    "[h1,m1,s1] = hora.split(':')             # Para separar a cadeia nas três componentes\n",
    "                                         # Não se preocupe, você vai aprender sobre funções e listas em próximas aulas\n",
    "print(h1,m1,s1)                          # Atenção: h1, m1, s1 são cadeias\n",
    "\n",
    "# Complete o código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: quem é mais velho?\n",
    "\n",
    "Alice e Bob querem saber quem deles é mais velho; porém não querem que o outro saiba a data do seu aniversário. Escreva um programa que leia as datas de aniversário de Alice e Bob no formato dd/mm/aaaa e determine quem deles é o mais velho ou se ambos têm a mesma idade. Adapte o segmento de código do exercício anterior para ler as datas. Seu programa deve validar que os dados lidos sejam corretos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: pedra-papel-tesoura\n",
    "\n",
    "Escreva um programa para ajudar a Alice e Bob a jogar pedra-papel-tesoura e imprimir o ganhador ou empate. Lembre-se: \n",
    "\n",
    "* pedra ganha de tesoura\n",
    "* tesoura ganha de papel \n",
    "* papel ganha de pedra\n",
    "* se os jogadores fizerem a mesma escolha, eles empatam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: cálculo de conceito \n",
    "\n",
    "A Profa. Alice também ministra a disciplina de Processamento da Informação (PI) na UFABC. A disciplina está dividida em aulas teoricas (teoria) e aulas em laboratório de Computação (prática). Em ambos casos, Alice fará duas provas e o critério de aprovação é ter média maior ou igual a  5.0. A atribuição do conceito tanto em teoria como em prática obedece à tabela abaixo:\n",
    "\n",
    "|  Média de Aproveitamento | Conceito |\n",
    "|-------------------------:|----------|\n",
    "|  Entre 9.0 e 10.0        |    A     |\n",
    "|  Entre 7.5 e 9.0         |    B     |\n",
    "|  Entre 6.0 e 7.5         |    C     |\n",
    "|  Entre 4.0 e 6.0         |    D     |\n",
    "|  Entre 4.0 e zero        |    F     |\n",
    "\n",
    "\n",
    "O conceito final de PI é calculado conforme a tabela abaixo:\n",
    "\n",
    "\n",
    "|  Teoria | Prática     | Conceito Final |\n",
    "|--------:|------------:|----------------|\n",
    "|  A      |    A, B     | A              |\n",
    "|  A      |    C, D     | B              |\n",
    "|  B      |    A, B, C  | B              |\n",
    "|  B      |     D       | C              |\n",
    "|  C      |     A       | B              |\n",
    "|  C      |    B, C, D  | C              |\n",
    "|  D      |    A, B     | C              |\n",
    "|  D      |    C, D     | C              |\n",
    "\n",
    "\n",
    "\n",
    "Se o conceito do aluno for F em teoria ou prática então o conceito final é F. Além disso, o número de faltas do aluno na disciplina não pode ultrapassar as 15 horas pois nesse caso, o conceito final é O. \n",
    "\n",
    "Faça um programa que leia as faltas e as notas de um aluno nas provas de teoria e prática de PI. O programa deve calcular o conceito final do aluno e mostrar a mensagem:\n",
    "\n",
    "* \"Reprovado por faltas\", se o número de faltas for maior de 15.\n",
    "* \"Reprovado\", se o conceito for F.\n",
    "* \"Aprovado com Distinção\", se o conceito for A.\n",
    "* \"Aprovado com conceito\", B, C ou D.\n",
    "\n",
    "**Observação**: evite ler dados e fazer cálculos desnecessários.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: classificação de pessoas\n",
    "\n",
    "Escreva um programa que faça entre cinco e dez perguntas com respostas \"Sim\" ou \"Não\" para uma pessoa e dependendo de cada resposta obtenha uma classificação/opinão/conselho para ela.\n",
    "\n",
    "Por exemplo, considere as seguintes cinco perguntas sobre um crime:\n",
    "\n",
    "* \"Telefonou para a vítima?\"\n",
    "* \"Esteve no local do crime?\"\n",
    "* \"Mora perto da vítima?\"\n",
    "* \"Devia para a vítima?\"\n",
    "* \"Já trabalhou com a vítima?\" \n",
    "\n",
    "As perguntas podem ser usadas para emitir uma classificação sobre a participação da pessoa no crime. Se a pessoa responder \"sim\" a 2 questões ela deve ser classificada como \"Suspeita\", entre 3 e 4 como \"Cúmplice\" e 5 como \"Assassino\". Caso contrário, ele será classificado como \"Inocente\".\n",
    "\n",
    "Seja criativo!!!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: dia seguinte\n",
    "\n",
    "Escreva um programa que leia uma data no formato dd/mm/aaaa e imprima o dia seguinte (sem considerar anos bissextos). Seu programa deve validar os dados lidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red;\">Lembre-se: as próximas células só estão presentes para personalizar a formatação deste _notebook_. </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<script>\n",
    "    // AUTORUN ALL CELLS ON NOTEBOOK-LOAD!\n",
    "    \n",
    "var myCSS = (function () {/*\n",
    "<style>\n",
    "\n",
    ".rendered_html h1 {\n",
    "    background-color: #555;\n",
    "    color: white;\n",
    "    padding: .5em;\n",
    "    // border-bottom: 2px solid #000;\n",
    "    // padding-bottom: .6em;\n",
    "    margin-bottom: 1em;\n",
    "}\n",
    "\n",
    ".rendered_html h2 {\n",
    "    border-bottom: 1px solid #333;\n",
    "    padding-bottom: .6em;\n",
    "}\n",
    "                                      \n",
    ".rendered_html h3 {\n",
    "    color: #034f84;\n",
    "}\n",
    "\n",
    ".rendered_html code  {\n",
    "    padding: 2px 4px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: #f9f2f4;\n",
    "    border-radius: 4px;\n",
    "}\n",
    "\n",
    ".rendered_html pre code {\n",
    "    padding: 0px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: rgba(0, 0, 0, 0);\n",
    "}\n",
    "\n",
    "kbd {\n",
    "    border-radius: 3px;  \n",
    "    padding: 2px, 3px;\n",
    "}\n",
    "\n",
    "body {\n",
    "    counter-reset: h1counter excounter;\n",
    "}\n",
    "h1:before {\n",
    "    content: counter(h1counter) \".\\0000a0\\0000a0\";\n",
    "    counter-increment: h1counter;\n",
    "}\n",
    "span.exec:before {\n",
    "    content: counter(excounter);\n",
    "    counter-increment: excounter;\n",
    "}\n",
    "\n",
    "</style>                 \n",
    "*/}).toString().match(/[^]*\\/\\*([^]*)\\*\\/\\}$/)[1];\n",
    "\n",
    "\n",
    "    require(\n",
    "        ['base/js/namespace', 'jquery'], \n",
    "        function(jupyter, $) {\n",
    "            $(jupyter.events).on(\"kernel_ready.Kernel\", function () {\n",
    "                console.log(\"Applying CSS...\");\n",
    "\n",
    "                var head = document.head || document.getElementsByTagName('head')[0],\n",
    "                    style = document.createElement('style');\n",
    "\n",
    "                style.type = 'text/css';\n",
    "                if (style.styleSheet){\n",
    "                  style.styleSheet.cssText = myCSS;\n",
    "                } else {\n",
    "                  style.appendChild(document.createTextNode(myCSS));\n",
    "                }\n",
    "\n",
    "                head.appendChild(style);\n",
    "            });\n",
    "            jupyter.actions.call('jupyter-notebook:save-notebook');\n",
    "        }\n",
    "    );\n",
    "</script>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<style>\n",
    "\n",
    ".rendered_html h1 {\n",
    "    background-color: #555;\n",
    "    color: white;\n",
    "    padding: .5em;\n",
    "    // border-bottom: 2px solid #000;\n",
    "    // padding-bottom: .6em;\n",
    "    margin-bottom: 1em;\n",
    "}\n",
    "\n",
    ".rendered_html h2 {\n",
    "    border-bottom: 1px solid #333;\n",
    "    padding-bottom: .6em;\n",
    "}\n",
    "                                      \n",
    ".rendered_html h3 {\n",
    "    color: #034f84;\n",
    "}\n",
    "\n",
    ".rendered_html code  {\n",
    "    padding: 2px 4px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: #f9f2f4;\n",
    "    border-radius: 4px;\n",
    "}\n",
    "\n",
    ".rendered_html pre code {\n",
    "    padding: 0px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: rgba(0, 0, 0, 0);\n",
    "}\n",
    "\n",
    "kbd {\n",
    "    border-radius: 3px;  \n",
    "    padding: 2px, 3px;\n",
    "}\n",
    "\n",
    "body {\n",
    "    counter-reset: h1counter excounter;\n",
    "}\n",
    "h1:before {\n",
    "    content: counter(h1counter) \".\\0000a0\\0000a0\";\n",
    "    counter-increment: h1counter;\n",
    "}\n",
    "span.exec:before {\n",
    "    content: counter(excounter);\n",
    "    counter-increment: excounter;\n",
    "}\n",
    "\n",
    "</style>           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}