CONDITIONALS.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6359f00d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O número da variável  numero1 é maior que o número da variável numero2\n"
     ]
    }
   ],
   "source": [
    "#Python função If ou seja função Se\n",
    "\n",
    "numero1 = 90\n",
    "numero2 = 12\n",
    "\n",
    "#Se a variável número1 é maior que a variável número 2\n",
    "if numero1 > numero2:\n",
    "    \n",
    "    print(\"O número da variável  numero1 é maior que o número da variável numero2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0039f68e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "728f89bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O número da variável numero1 é igual ao número da variável numero2\n"
     ]
    }
   ],
   "source": [
    "#Python função If... elif\n",
    "#if - Se\n",
    "#elif - Senão Se\n",
    "\n",
    "numero1 = 6\n",
    "numero2 = 6\n",
    "\n",
    "if numero1 > numero2:\n",
    "    \n",
    "    print(\"O número da variável  numero1 é maior que o número da variável numero2\")\n",
    "    \n",
    "elif numero1 == numero2:\n",
    "    \n",
    "    print(\"O número da variável numero1 é igual ao número da variável numero2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57121af6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7f3f9f35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tente adivinhar o número secreto entre 1 e 10: 7\n",
      "Parabéns! Você adivinhou o número secreto.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício:\n",
    "\n",
    "Adivinhe o Número Secreto\n",
    "\n",
    "Você foi desafiado a adivinhar um número secreto entre 1 e 10!\n",
    "\n",
    "    Execute o programa.\n",
    "    Insira um número inteiro entre 1 e 10 quando solicitado.\n",
    "    O programa irá informar se você adivinhou corretamente o número secreto ou não.\n",
    "\n",
    "Seu objetivo é descobrir qual é o número secreto. Você pode executar o programa \n",
    "quantas vezes quiser até adivinhar corretamente.\n",
    "\n",
    "Nota: Para fins deste exercício, o número secreto é fixo e é igual a 7. Em uma \n",
    "versão mais avançada do exercício, você poderia modificar o programa para escolher um número \n",
    "secreto aleatório cada vez que é executado.\n",
    "\"\"\"\n",
    "\n",
    "# Define o número secreto que o usuário deve adivinhar\n",
    "numero_secreto = 7\n",
    "\n",
    "# Solicita ao usuário para inserir um número inteiro entre 1 e 10\n",
    "chute = int(input(\"Tente adivinhar o número secreto entre 1 e 10: \"))\n",
    "\n",
    "# Verifica se o número inserido pelo usuário é igual ao número secreto\n",
    "if chute == numero_secreto:\n",
    "    \n",
    "    # Se o usuário adivinhar corretamente, imprime uma mensagem de sucesso\n",
    "    print(\"Parabéns! Você adivinhou o número secreto.\")\n",
    "\n",
    "#else - Senão\n",
    "else:\n",
    "    \n",
    "    # Se o usuário adivinhar errado, imprime uma mensagem de erro\n",
    "    print(\"Desculpe, você não adivinhou o número secreto. Tente novamente!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bc017d5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e7faa31c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Por favor, digite sua idade: 15\n",
      "Você não é elegivel para votar.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício:\n",
    "\n",
    "Verifique a Elegibilidade para Votar\n",
    "\n",
    "Neste exercício, você vai executar um programa que determina \n",
    "se uma pessoa está ou não elegível para votar com base em sua idade.\n",
    "\n",
    "    Execute o programa.\n",
    "    Insira sua idade quando solicitado.\n",
    "    O programa irá informar se você é elegível para votar ou não.\n",
    "\n",
    "Note que a idade mínima para votar é de 18 anos.\n",
    "\"\"\"\n",
    "\n",
    "# Pergunta ao usuário sua idade\n",
    "idade = int(input(\"Por favor, digite sua idade: \"))\n",
    "\n",
    "#if - se\n",
    "# Verifica se a idade é maior ou igual a 18\n",
    "if idade >= 18:\n",
    "    \n",
    "    # Se a idade for maior ou igual a 18, imprime que o usuário está elegível para votar\n",
    "    print(\"Você é elegivel para votar.\")\n",
    "\n",
    "#else - senão\n",
    "else:\n",
    "    \n",
    "    # Se a idade for menor que 18, imprime que o usuário não está elegível para votar\n",
    "    print(\"Você não é elegivel para votar.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "756bf637",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a369d8a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Abaixo está uma tabela que explica os diferentes operadores de comparação \n",
    "que você pode usar com uma instrução if em Python. Esses operadores permitem \n",
    "comparar valores, o que é frequentemente necessário em programação condicional.\n",
    "\n",
    "Operador    Descrição              Exemplo      Resultado\n",
    ">           Maior que              5 > 3        True\n",
    "<           Menor que              5 < 3        False\n",
    "==          Igual a                5 == 5       True\n",
    "!=          Diferente de           5 != 3       True\n",
    ">=          Maior que ou igual a   5 >= 5       True\n",
    "<=          Menor que ou igual a   5 <= 3       False\n",
    "\n",
    "Você pode usar esses operadores em uma instrução if para testar condições \n",
    "específicas. Aqui estão alguns exemplos de como você poderia usar esses \n",
    "operadores em condições:\n",
    "\n",
    "if x > y:\n",
    "    print(\"x é maior que y\")\n",
    "elif x < y:\n",
    "    print(\"x é menor que y\")\n",
    "elif x == y:\n",
    "    print(\"x é igual a y\")\n",
    "else:\n",
    "    print(\"x e y são incomparáveis\")\n",
    "\n",
    "Esses operadores formam a base para muitas construções lógicas e condicionais \n",
    "em Python e são ferramentas essenciais na caixa de ferramentas de qualquer programador.\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "235cfb93",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4fc5e0b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O 9 é maior que o 6\n"
     ]
    }
   ],
   "source": [
    "#Função If... elif ... else\n",
    "#Se... Senão Se ... Senão\n",
    "\n",
    "numero1 = 9\n",
    "numero2 = 6\n",
    "\n",
    "if numero1 > numero2:\n",
    "    \n",
    "    print(f\"O {numero1} é maior que o {numero2}\")\n",
    "    \n",
    "elif numero1 == numero2:\n",
    "    \n",
    "    print(f\"O {numero1} é IGUAL ao {numero2}\")\n",
    "    \n",
    "else:\n",
    "    \n",
    "    print(f\"O {numero1} é MENOR que o {numero2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e129df88",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "952f95b5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "As duas condições são verdadeiras\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#and - E\n",
    "\n",
    "numero1 = 50\n",
    "numero2 = 21\n",
    "numero3 = 200\n",
    "\n",
    "if numero1 > numero2 and numero3 > numero1:\n",
    "    \n",
    "    print(\"As duas condições são verdadeiras\")\n",
    "    \n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "    Definindo Variáveis: Três variáveis são definidas, numero1 com o valor \n",
    "    50, numero2 com o valor 21, e numero3 com o valor 200.\n",
    "\n",
    "    Condição Composta (if):\n",
    "        Primeira Condição: Verifica se numero1 é maior que numero2, ou seja, \n",
    "        se 50 é maior que 21. Essa condição é verdadeira.\n",
    "        \n",
    "        Segunda Condição: Verifica se numero3 é maior que numero1, ou \n",
    "        seja, se 200 é maior que 50. Essa condição também é verdadeira.\n",
    "        \n",
    "        Operador and: A cláusula if usa o operador lógico and, o que significa \n",
    "        que ambas as condições devem ser verdadeiras para que o bloco de código \n",
    "        sob o if seja executado.\n",
    "\n",
    "    Execução da Condição: Como ambas as condições são verdadeiras, o bloco de \n",
    "    código indentado abaixo da declaração if é executado. Isso resulta na impressão \n",
    "    da mensagem \"As duas condições são verdadeiras\" no console.\n",
    "\n",
    "O código usa o operador lógico and para verificar duas condições simultaneamente e \n",
    "imprimir uma mensagem se ambas forem verdadeiras. Neste exemplo, como ambas as condições \n",
    "são verdadeiras, a mensagem será impressa.\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39968fd8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "31e632d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Por favor, digite a nota do estudante (0-100): 40\n",
      "Insuficiente!\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício:\n",
    "\n",
    "Classificação de Notas\n",
    "\n",
    "Neste exercício, seu objetivo é executar um programa que \n",
    "classifica as notas de um estudante em diferentes categorias.\n",
    "\n",
    "    Execute o programa.\n",
    "    \n",
    "    Insira a nota do estudante quando solicitado (entre 0 e 100).\n",
    "    \n",
    "    O programa irá informar a classificação da nota de acordo com os seguintes critérios:\n",
    "        Excelente: 90-100\n",
    "        Bom: 70-89\n",
    "        Satisfatório: 50-69\n",
    "        Insuficiente: 0-49\n",
    "\"\"\"\n",
    "\n",
    "nota = int(input(\"Por favor, digite a nota do estudante (0-100): \"))\n",
    "\n",
    "#Verifica em qual categoria a nota se encaixa\n",
    "if nota >= 90 and nota <= 100:\n",
    "    \n",
    "    print(\"Excelente!\")\n",
    "    \n",
    "elif nota >= 70 and nota <= 89:\n",
    "    \n",
    "    print(\"Bom!\")\n",
    "    \n",
    "elif nota >= 50 and nota <= 69:\n",
    "    \n",
    "    print(\"Satisfatório!\")\n",
    "    \n",
    "else:\n",
    "    \n",
    "    print(\"Insuficiente!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c463dd52",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fb926e5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Por favor, digite o valor da sua compra: R$ 200\n",
      "Você não recebeu desconto.\n",
      "Valor do desconto: R$ 0.00\n",
      "Valor final da compra: R$ 200.00\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício:\n",
    "\n",
    "Calculadora de Descontos\n",
    "\n",
    "Você é um cliente em uma loja que está tendo uma promoção especial. Dependendo \n",
    "do valor da sua compra, você pode receber um desconto!\n",
    "\n",
    "    Execute o programa.\n",
    "    \n",
    "    Insira o valor da sua compra quando solicitado.\n",
    "    \n",
    "    O programa irá calcular e informar o valor do desconto aplicado e o valor final \n",
    "    com o desconto.\n",
    "\n",
    "Os descontos são aplicados da seguinte forma:\n",
    "\n",
    "    Compras acima de R$1000 recebem 20% de desconto.\n",
    "    Compras de R$500 a R$1000 recebem 10% de desconto.\n",
    "    Compras abaixo de R$500 não recebem desconto.\n",
    "    \n",
    "    \n",
    "\"\"\"\n",
    "\n",
    "# Solicita ao usuário o valor da compra\n",
    "valor_compra = float(input(\"Por favor, digite o valor da sua compra: $\"))\n",
    "\n",
    "# Verifica em qual categoria de desconto a compra se encaixa\n",
    "if valor_compra > 1000:\n",
    "    \n",
    "    # Se a compra for maior que R$1000, aplica um desconto de 20%\n",
    "    desconto = 0.20 * valor_compra\n",
    "    \n",
    "    # Imprime uma mensagem informando o desconto de 20%\n",
    "    print(\"Você recebeu 20% de desconto!\")\n",
    "    \n",
    "elif valor_compra >= 500 and valor_compra <= 1000:\n",
    "    \n",
    "    # Se a compra for entre R$500 e R$1000, aplica um desconto de 10%\n",
    "    desconto = 0.10 * valor_compra\n",
    "    \n",
    "    # Imprime uma mensagem informando o desconto de 10%\n",
    "    print(\"Você recebeu 10% de desconto!\")\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Se a compra for menor que $500, não aplica desconto\n",
    "    desconto = 0\n",
    "    \n",
    "    # Imprime uma mensagem informando que não há desconto\n",
    "    print(\"Você não recebeu desconto.\")\n",
    "\n",
    "# Calcula o valor final após o desconto\n",
    "valor_final = valor_compra - desconto\n",
    "\n",
    "# Imprime o valor do desconto e o valor final da compra\n",
    "print(f\"Valor do desconto: R${desconto:.2f}\")\n",
    "print(f\"Valor final da compra: R${valor_final:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e177c7a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f7427438",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O 19 é maior que 150 ou o 19 é maior que 18!\n"
     ]
    }
   ],
   "source": [
    "#If ... Or\n",
    "#Se ... Ou\n",
    "\n",
    "numero1 = 19\n",
    "numero2 = 150\n",
    "numero3 = 18\n",
    "\n",
    "if numero1 > numero2 or numero1 > numero3:\n",
    "    \n",
    "    print(f\"O {numero1} é maior que {numero2} ou o {numero1} é maior que {numero3}!\")\n",
    "    \n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "    Definindo Variáveis: Três variáveis são definidas, numero1 com o valor 19, numero2 \n",
    "    com o valor 150, e numero3 com o valor 18.\n",
    "\n",
    "    Condição Composta (if):\n",
    "    \n",
    "        Primeira Condição: Verifica se numero1 é maior que numero2, ou seja, se \n",
    "        19 é maior que 150. Essa condição é falsa.\n",
    "        \n",
    "        Segunda Condição: Verifica se numero1 é maior que numero3, ou seja, se \n",
    "        19 é maior que 18. Essa condição é verdadeira.\n",
    "        \n",
    "        Operador or: A cláusula if usa o operador lógico or, o que significa \n",
    "        que pelo menos uma das condições deve ser verdadeira para que o bloco de \n",
    "        código sob o if seja executado.\n",
    "\n",
    "    Execução da Condição: Como pelo menos uma das condições é verdadeira (a segunda), o \n",
    "    bloco de código indentado abaixo da declaração if é executado. Isso resulta na impressão \n",
    "    da mensagem \"Meu número 1 é maior que umas ou mais condições\" no console.\n",
    "\n",
    "O código usa o operador lógico or para verificar duas condições simultaneamente e imprimir uma \n",
    "mensagem se pelo menos uma delas for verdadeira. Neste exemplo, como a segunda condição é \n",
    "verdadeira, a mensagem será impressa.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "680c8da3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e90d0996",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Você possui um convite VIP? (sim/não):não\n",
      "Você está na lista de convidados? (sim/não):não\n",
      "Você é um membro do clube? (sim/não):não\n",
      "Desculpe, você não pode entrar no evento.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício\n",
    "\n",
    "Entrada para um Evento Exclusivo\n",
    "\n",
    "Você foi convidado para um evento exclusivo. Para entrar, você deve \n",
    "atender a pelo menos uma das seguintes condições:\n",
    "\n",
    "    Ter um convite VIP.\n",
    "    Estar na lista de convidados.\n",
    "    Ser um membro do clube.\n",
    "\n",
    "    Execute o programa.\n",
    "    \n",
    "    Responda às perguntas fornecidas com 'sim' ou 'não'.\n",
    "    O programa irá informar se você pode entrar no evento ou não.\n",
    "    \n",
    "    \n",
    "    Bem-vindo(a) ao evento!\n",
    "    Desculpe, você não pode entrar no evento.\n",
    "    \n",
    "\"\"\"\n",
    "\n",
    "# Pergunta ao usuário se possui um convite VIP\n",
    "convite_vip = input(\"Você possui um convite VIP? (sim/não):\")\n",
    "\n",
    "# Pergunta ao usuário está na lista de convidados\n",
    "na_lista = input(\"Você está na lista de convidados? (sim/não):\")\n",
    "\n",
    "# Pergunta ao usuário se é um membro do clube\n",
    "membro_clube = input(\"Você é um membro do clube? (sim/não):\")\n",
    "       \n",
    "# Verifica se o usuário atende a pelo menos uma das condições\n",
    "if convite_vip == \"sim\" or na_lista  == \"sim\" or membro_clube == \"sim\":\n",
    "                  \n",
    "    # Se atender a pelo menos uma das condições, permite a entrada\n",
    "    print(\"Bem-vindo(a) ao evento!\")\n",
    "                     \n",
    "else:\n",
    "    \n",
    "    # Se não atender a nenhuma das condições, nega a entrada\n",
    "    print(\"Desculpe, você não pode entrar no evento.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21932268",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "0ee9859b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número: 29\n",
      "O número 29 é IMPAR\n"
     ]
    }
   ],
   "source": [
    "#Exercicio Par ou Impar\n",
    "#Crie um algoritmo que solicite a entrada de um número positivo e inteiro e imprima se o\n",
    "#número é PAR ou IMPAR\n",
    "\n",
    "n1 = int(input(\"Digite um número: \"))\n",
    "\n",
    "verificaNumero = n1 % 2\n",
    "\n",
    "if verificaNumero == 0:\n",
    "    \n",
    "    print(f\"O número {n1} é PAR\")\n",
    "    \n",
    "else:\n",
    "    \n",
    "    print(f\"O número {n1} é IMPAR\")\n",
    "    \n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "    Entrada do Usuário: A função input(\"Digite um número \") solicita ao usuário \n",
    "    que digite um número. O texto dentro dos parênteses é a mensagem mostrada ao usuário.\n",
    "\n",
    "    Conversão para Inteiro: A função int() converte a entrada do usuário (que é uma \n",
    "    string) em um número inteiro. Esse valor é então armazenado na variável n1.\n",
    "\n",
    "    Verificando Par ou Ímpar: O operador % calcula o resto da divisão de n1 por 2. Se o \n",
    "    número for par, o resto dessa divisão será 0; se for ímpar, será 1. O resultado é \n",
    "    armazenado na variável verificaNumero.\n",
    "\n",
    "    Condição (if-else):\n",
    "    \n",
    "        Se Par: Se verificaNumero for igual a 0, isso significa que n1 é par, e \n",
    "        a mensagem \"O número \", n1, \" é PAR\" é impressa.\n",
    "        \n",
    "        Se Ímpar: Se verificaNumero não for igual a 0 (ou seja, for 1), isso \n",
    "        significa que n1 é ímpar, e a mensagem \"O número \", n1, \" é IMPAR\" é impressa.\n",
    "\n",
    "O código é um exemplo simples de como receber uma entrada do usuário e realizar \n",
    "uma operação aritmética para determinar uma propriedade específica do número (neste caso, \n",
    "se ele é par ou ímpar) e, em seguida, imprimir uma mensagem correspondente.\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1198b837",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "80155687",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "menor de idade\n"
     ]
    }
   ],
   "source": [
    "#Estrutura condicional ternária\n",
    "\n",
    "#age - idade\n",
    "\n",
    "age = 17\n",
    "status = \"adulto\" if age >= 18 else \"menor de idade\"\n",
    "print(status) #Saída: \"adulto\"\n",
    "\n",
    "\"\"\"\n",
    "Neste exemplo, a variável status recebe o valor \"adulto\" se \n",
    "age for maior ou igual a 18 e \"menor de idade\" caso contrário. Essa \n",
    "linha de código usa uma expressão condicional para fazer isso de forma \n",
    "concisa em uma única linha. Isso pode ser útil para tornar o código mais \n",
    "compacto, mas deve ser usado com cuidado para não comprometer a legibilidade.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f862fff9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "ac22d5b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "par\n"
     ]
    }
   ],
   "source": [
    "#Suponhamos que você queira determinar se um número é par ou impar:\n",
    "\n",
    "numero = 42\n",
    "resultado = \"par\" if numero % 2 == 0 else \"impar\"\n",
    "print(resultado) #Saída: \"par\"\n",
    "\n",
    "\"\"\"\n",
    "Neste exemplo, a variável resultado receberá o valor \"par\" se \n",
    "o número for divisível por 2 e \"ímpar\" caso contrário. Isso é \n",
    "feito usando uma expressão condicional em uma única linha, que \n",
    "avalia a condição numero % 2 == 0 e seleciona o valor correspondente.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "c53522ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alta\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Suponha que você tenha pontuação e queira categoriza-la\n",
    "#como \"baixa\", \"média\" ou \"alta\"\n",
    "\n",
    "score = 85\n",
    "categoria = \"baixa\" if score < 50 else \"média\" if score < 80 else \"alta\"\n",
    "print(categoria)\n",
    "\n",
    "\"\"\"\n",
    "Exemplo de uma expressão condicional aninhada (ou ternária) em Python. \n",
    "\n",
    "Vamos dividi-la em partes para entender melhor:\n",
    "\n",
    "    \"baixa\" if score < 50: Se a pontuação (score) for menor que 50, a expressão inteira \n",
    "    será avaliada como \"baixa\".\n",
    "\n",
    "    \"média\" if score < 80: Se a primeira condição não for atendida (ou seja, a pontuação \n",
    "    é maior ou igual a 50) e a pontuação for menor que 80, a expressão será avaliada \n",
    "    como \"média\".\n",
    "\n",
    "    \"alta\": Se nenhuma das condições acima for atendida (ou seja, a pontuação é \n",
    "    maior ou igual a 80), a expressão será avaliada como \"alta\".\n",
    "\n",
    "Portanto, a expressão inteira é equivalente a uma série de verificações if ... elif ... else que \n",
    "categoriza a pontuação em \"baixa\", \"média\" ou \"alta\" com base nos critérios definidos.\n",
    "\n",
    "Aqui está uma representação equivalente usando uma estrutura condicional mais tradicional:\n",
    "\n",
    "if score < 50:\n",
    "    category = \"baixa\"\n",
    "elif score < 80:\n",
    "    category = \"média\"\n",
    "else:\n",
    "    category = \"alta\"\n",
    "\n",
    "A versão de uma linha é mais concisa, mas a versão expandida pode ser mais legível, especialmente \n",
    "se houver muitas condições aninhadas.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf7bfec1",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}