3_Condicionais.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "3 - Condicionais.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "_jzeEkjMijri",
        "ZS2sIWTBTFa6",
        "NXDKxSKlqBUm",
        "u5chNTQ7WFhS",
        "ISd832UXWPmB",
        "N3KLFgPsCIhm",
        "RyJl5RL2ILze"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PetEletricaUfes/MiniCursoPython/blob/main/3_Condicionais.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nVcUfxStiUqF"
      },
      "source": [
        "><a href=\"https://www.ufes.br/\">\n",
        "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/Bras%C3%A3o_Ufes.svg/1200px-Bras%C3%A3o_Ufes.svg.png\" alt=\"Drawing\" width=\"85\"></a>\n",
        "<img width=\"80\"> \n",
        "<a href=\"https://www.peteletrica.ufes.br/\">\n",
        "<img src=\"https://engenhariaeletrica.ufes.br/sites/engenhariaeletrica.ufes.br/files/imagem/logo_pet_preta.png\" alt=\"Drawing\" width=\"280\"></a>  <center> \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0PE-8ceriaZB"
      },
      "source": [
        "## Lesson 03: Condicionais\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_jzeEkjMijri"
      },
      "source": [
        "# Introdução\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jd-7BCjQi_6V"
      },
      "source": [
        ">Durante a interpretação de programas, existirão momentos em que uma ação deverá ser tomada e outra não.\n",
        "\n",
        ">Para que isso ocorra são necessárias as estruturas condicionais que irão fazer controle do fluxo do programa."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZS2sIWTBTFa6"
      },
      "source": [
        "# Operadores de comparação"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oczWmXjITLLs"
      },
      "source": [
        ">Em Python existem alguns operadores que conseguem realizar comparaçoes entre valores:\n",
        "\n",
        ">`x > y    #maior que`<br>\n",
        ">`x < y    #menor que`<br>\n",
        ">`x >= y   #maior ou igual a`<br>\n",
        ">`x <= y   #menor ou igual a`<br>\n",
        ">`x == y   #igual a`<br>\n",
        ">`x != y   #diferente de`<br>\n",
        "\n",
        ">Em Python, essas comparações ou expressões lógicas retornam um tipo Booleano com valor `True` (verdadeiro) ou `False` (falso)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NXDKxSKlqBUm"
      },
      "source": [
        "# Operadores condicionais if, else e elif\n",
        "\n",
        ">Vimos que as comparações lógicas nos retornam valores `True` e `False`. Agora vamos ver o que podemos fazer com essa informação.\n",
        "\n",
        ">As estruturas condicinais definem se uma parte do código será interpretada ou outra.\n",
        "\n",
        ">Em Python, a estrutura usada para decisões é o `if`.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FC3yhMWlh35-"
      },
      "source": [
        "#Exemplo 01\n",
        "\n",
        "variavel = 2\n",
        "if variavel > 3:\n",
        "  print(\"Você está certo!!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SNOpg7FKrwBH"
      },
      "source": [
        ">No Exemplo 01, se o valor da variável for menor do que 3, o código dentro do `if` será interpretado.\n",
        "\n",
        ">Se a variável não atender a condição do `if` e, no Exemplo 01, ser menor do que 3, o código irá desconsiderar as linhas dentro do `if`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v9mV-d1Et1_A"
      },
      "source": [
        "#Exemplo 02\n",
        "print(\"Vou tentar adivinhar a sua idade\\n\")\n",
        "idade = 19\n",
        "if idade < 20:\n",
        "  print(\"Errei :(\")\n",
        "if idade == 20:\n",
        "  print(\"Vc tem 20 anos!!\")\n",
        "\n",
        "print(\"Na próxima eu acerto :/\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JOhrPSVow9Mu"
      },
      "source": [
        ">O problema no Exemplo 02 é que quando a lógica do `if` é falsa o programa continua sendo executado. Por isso, visualizamos mais de um texto."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jKnO9ApB04FP"
      },
      "source": [
        ">No Exemplo 02, vimos como usar `if` para executar uma ação se a condição for verdadeira.\n",
        ">Caso a condição não seja verdadeira usamos o else. \n",
        ">Quando a lógica do `if` não é atendida, necessarimanete o bloco de código debtro do `else` é executado. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S9rY3mB4wTCE"
      },
      "source": [
        "#Exemplo 03\n",
        "\n",
        "sono = False\n",
        "if sono:\n",
        "  print(\"Vou dormir mais um pouquinho...\")\n",
        "else:\n",
        "  print(\"Levantei, levantei\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aFcxwtDA5euu"
      },
      "source": [
        ">Tente fazer um programa que imprima o maior valor entre duas opções:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nt5LGHXY5Uek"
      },
      "source": [
        "#Exercício 1\n",
        "\n",
        "x = 88.97\n",
        "y = 91.4\n",
        "\n",
        "#Agora escreva esse programa que diz qual é o maior\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VyPW5OaY0wBe"
      },
      "source": [
        "#Exemplo 04\n",
        "\n",
        "meuDinheiro = 5\n",
        "compras = 6\n",
        "\n",
        "if meuDinheiro > compras:\n",
        "  print(\"Sobrou dinheiro! :D\")\n",
        "\n",
        "elif meuDinheiro < compras:\n",
        "  print(\"Vou ter que pedir emprestado\")\n",
        "\n",
        "else:\n",
        "  print(\"Não sobrou dinheiro :/\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oPbj3uJ551zg"
      },
      "source": [
        ">Se existir mais de uma condição precisa ser verificada, usamos o `elif` para avaliar as expressões intermediárias antes do `else`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "32ZHhSk17IUV"
      },
      "source": [
        ">Os operadores condicionais funcionam também com outros tipos de dados além dos numéricos. \n",
        "\n",
        ">Também é possível fazer comparações com strings. Então, faça um programa que diga se uma palavra tem mais, menos ou extamente 7 letras."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YrgdWKih7q95"
      },
      "source": [
        "#Exercício 2\n",
        "\n",
        "#Mude seu valor para a palavra que você escolheu.\n",
        "\n",
        "\n",
        "#Escreva aqui o programa que nos diz se ela tem menos, mais ou exatamente 7 letras. \n",
        "#Dica: tente usar a função 'len(palavra)'que retorna o comprimento de uma string.\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u5chNTQ7WFhS"
      },
      "source": [
        "# Operador in e not in"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T55WDpIW6U1U"
      },
      "source": [
        "5 in (1,3,5,7,8)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f44ogoeP2QPj"
      },
      "source": [
        ">O operador in verifica se o número da esquerda está contido na sequência da direita."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mIp664rd25PW"
      },
      "source": [
        "if 3 not in range(1,5):\n",
        "  print(\"Não to aqui\")\n",
        "else:\n",
        "  print(\"To aqui\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ZFJr0JW7kv-"
      },
      "source": [
        ">O not in verifica se o objeto da esquerda não está contido na direita."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4giQmN6Y9s1k"
      },
      "source": [
        ">Esses operadores também podem ser usados com outros tipos como strings.\n",
        "\n",
        ">Faça um programa que diga se uma palavra está contida em uma frase de sua escolha."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OXtsrM7a-Kd3"
      },
      "source": [
        "#Exercício 3\n",
        "\n",
        "#Mude seu valor para a palavra e frase que você escolheu.\n",
        "\n",
        "\n",
        "#Escreva aqui o programa que diz se a sua palavra está dentro da sua frase. \n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ISd832UXWPmB"
      },
      "source": [
        "# Operadores lógicos not, and e or"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QMynYENvXoJy"
      },
      "source": [
        ">Os operadores lógicos permitem fazer teste condicionais.\n",
        "\n",
        ">`not` - inverte o valor da entrada. Ou seja, quando aplicado ao valor True, o operador `not` retorna False; Quando aplicado ao valor False, o operador `not` retorna True. \n",
        "\n",
        ">`and` - Verdadeiro quando os dois elementos envolvidos são verdadeiros. Pode-se fazer uma analogia com o operador de multiplicação!\n",
        "\n",
        ">`or` - Verdadeiro quando um ou dois elementos envolvidos são verdadeiros. Pode-se fazer uma analogia com o operador de soma!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZsvD6-VqCNgT"
      },
      "source": [
        "<table>\n",
        "  <caption><strong>Operadores</strong></caption>\n",
        "\n",
        "  <tr>\n",
        "    <th>A</th>\n",
        "    <th>B</th>\n",
        "    <th>Saída OR</th>\n",
        "    <th>Saída AND</th>\n",
        "  </tr>\n",
        "\n",
        "  <tr>\n",
        "    <td>True</td>\n",
        "    <td>True</td>\n",
        "    <td>True</td>\n",
        "    <td>True</td>\n",
        "  </tr>\n",
        "\n",
        "  <tr>\n",
        "    <td>True</td>\n",
        "    <td>False</td>\n",
        "    <td>True</td>\n",
        "    <td>False</td>\n",
        "  </tr>\n",
        "\n",
        "  <tr>\n",
        "    <td>False</td>\n",
        "    <td>True</td>\n",
        "    <td>True</td>\n",
        "    <td>False</td>\n",
        "  </tr>\n",
        "\n",
        "  <tr>\n",
        "    <td>False</td>\n",
        "    <td>False</td>\n",
        "    <td>False</td>\n",
        "    <td>False</td>\n",
        "  </tr>\n",
        "\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DqzOpIAq_elN"
      },
      "source": [
        ">Exemplos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XaMrrBJL9F-I"
      },
      "source": [
        "um = True\n",
        "not um"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lg5sUulB9GT5"
      },
      "source": [
        "um = True\n",
        "zero = False\n",
        "\n",
        "um or zero"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "np7_GnxI9dm-"
      },
      "source": [
        "um = True\n",
        "zero = False\n",
        "\n",
        "um and zero"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OybxEuBWCvv9"
      },
      "source": [
        "1 and 7 in range(1,10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dsRzNscIC2gX"
      },
      "source": [
        "(8 or -4) not in range(-5,18)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eI1NEIEkDHAJ"
      },
      "source": [
        "num = 20\n",
        "if (num % 2 == 0) and (num % 5 == 0):\n",
        "  print(\"O número %.02f é par e divisível por 5\" %num)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PCyXKFnIBj1W"
      },
      "source": [
        ">Faça um programa que recebe três números e informe o maior entre eles."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tPPs8MfCBzb7"
      },
      "source": [
        "#Exercício 4\n",
        "\n",
        "num1 = -2\n",
        "num2 = 4\n",
        "num3 = 3.18\n",
        "\n",
        "#Escreva programa que diz qual dos três números é o maior\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N3KLFgPsCIhm"
      },
      "source": [
        "# Sentença if em uma única linha"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-8HJe-b3FJh8"
      },
      "source": [
        ">Formato: \n",
        "\n",
        ">variavel = expressão if(condição) else expressão\n",
        "\n",
        ">"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4du-Al9GD8hb"
      },
      "source": [
        "amarelo = 1\n",
        "vermelho = 1\n",
        "laranja = amarelo and vermelho\n",
        "cor = \"laranja\" if (laranja) else \"Não é laranja\"\n",
        "print(cor)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ARsIkt_gHwR9"
      },
      "source": [
        "lista = [-3,5,8,6,1,-9,2,10,20,1]\n",
        "valor = -9\n",
        "var = \"Está\" if (valor in lista) else \"Não está\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RyJl5RL2ILze"
      },
      "source": [
        "# Funções all e any"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VfbDujA-ISMb"
      },
      "source": [
        "**all(seq):**\n",
        "\n",
        "> A função recebe como parâmetro uma sequência (como uma lista ou uma tupla) e verifica se todos os elementos da sequência são verdadeiros.\n",
        "\n",
        ">Dessa forma, é possível substituir uma longa expressão booleana com ands por all(seq)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eSjYnU3FJ3-O"
      },
      "source": [
        "if 1<2 and 2<3 and 3<4 and 4<5 and 5<6 and 6<7 and 7<8 and 8<9 and 9==9:\n",
        "  print(\"Todas as condições são verdadeiras\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E8DWfXIbKhU1"
      },
      "source": [
        "if all([1<2, 2<3, 3<4, 4<5, 5<6, 6<7, 7<8, 8<9, 9==9]):\n",
        "  print(\"Todas as condições são verdadeiras\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IokUlbvKK0G2"
      },
      "source": [
        "**any(seq):**\n",
        "\n",
        ">any() (alguns, em português) verifica se alguns dos elementos contidos na sequência seq são verdadeiros.\n",
        "\n",
        ">Dessa forma, é possível substituir uma longa expressão booleana com ors por any(seq)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BpjGQBF3Ldnw"
      },
      "source": [
        "if 1>2 or 2>3 or 3>4 or 4>5 or 5<6 or 6>7 or 7>8 or 8>9 or 9==9:\n",
        "  print(\"Pelo menos uma condição é verdadeira\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kPV7MSZUMFbW"
      },
      "source": [
        "seq = [1>2, 2>3, 3>4, 4>5, 5<6, 6>7, 7>8, 8>9, 9==9]\n",
        "if any(seq):\n",
        "  print(\"Pelo menos uma condição é verdadeira\")"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}