Python-comparacoes-operadores-logicos.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparações e operadores lógicos\n",
    "\n",
    "No arquivo de [primeiros passos](Python-primeiros-passos.ipynb) estudamos as operações aritméticas, soma, subtração, etc. Agora, vamos estudar os operadores de comparação e também os operadores lógicos em Python, que são os que permitem que as estruturas de repetição e condicionais funcionem de acordo com as regras que estabelecemos e auxiliem na tomada de decisão.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparações\n",
    "\n",
    "Os operadores de comparação são utilizados para comparar valores e retornar resultados booleanos (Lembra deles? São os que assumem valor True ou False) com base nas relações entre eles. Esses operadores são os mesmos que você viu nas aulas de matemática:\n",
    "\n",
    "* == (igual a): Verifica se dois valores são iguais. Observe que `==` (comparação) é diferente de `=` (atribuição de variáveis)\n",
    "* != (diferente de): Verifica se dois valores são diferentes.\n",
    "* \\> (maior que): Verifica se o valor à esquerda é maior que o valor à direita.\n",
    "* < (menor que): Verifica se o valor à esquerda é menor que o valor à direita.\n",
    "* \\>= (maior ou igual a): Verifica se o valor à esquerda é maior ou igual ao valor à direita.\n",
    "* <= (menor ou igual a): Verifica se o valor à esquerda é menor ou igual ao valor à direita.\n",
    "\n",
    "Vamos aos exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo com operador '=='\n",
    "a = 5\n",
    "b = 10\n",
    "a == b\n",
    "# Saída: False, pois a não é igual a b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo com operador '!='\n",
    "a != b\n",
    "# Saída: True, pois a é diferente de b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo com operador '>'\n",
    "a > b\n",
    "# Saída: False, pois 5 não é maior que 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo com operador '<'\n",
    "a < b\n",
    "# Saída: True, pois 5 é menor que 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo com operador '>='\n",
    "# Observe que é possível fazer contas nas expressões de comparação\n",
    "a+5 >= b\n",
    "# Saída: True, pois a=5 + 5 é igual a 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo com operador '<='\n",
    "a <= b\n",
    "# Saída: True, pois 5 é menor que 10"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡Para saber mais sobre operadores de comparação: https://docs.python.org/3/reference/expressions.html#comparisons\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operadores lógicos\n",
    "\n",
    "Operadores lógicos são utilizados para realizar operações com valores booleanos, ou seja, apenas operações que envolvem valores True (verdadeiro) e False (falso). Existem 3 operadores:\n",
    "\n",
    "* AND (&): Em tradução do inglês, seria o operador \"E\". Quando você combina duas condições com \"E\", o resultado é verdadeiro somente se ambas as condições forem verdadeiras. Exemplo: Se você está no parque e está ensolarado, você vai tomar sorvete. Ou seja, você só vai tomar sorvete se ambas as condições forem satisfeitas. Se você não estiver no parque, mas estiver ensolarado, ainda assim você não vai tomar sorvete, e vice-versa.\n",
    "* OR (|): Em tradução do inglês, seria o operador \"OU\". Quando você combina duas condições com \"OU\", o resultado é verdadeiro se pelo menos uma das condições for verdadeira. Exemplo: Se você tem dinheiro ou tem um cartão de crédito, você pode comprar um sorvete (embora eu não recomende na segunda ocasião 😃). Ou seja, basta que uma das condições seja satisfeita, para que você possa comprar o sorvete.\n",
    "* ! (not): Em tradução do inglês, seria o operador \"NÃO\". Basicamente, a operação \"NÃO\" é uma negação, ou seja, ela inverte o valor de uma variável booleana. Se algo é verdadeiro, a negação torna falso, e vice-versa.\n",
    "\n",
    "Em resumo, temos a seguinte tabela:\n",
    "\n",
    "x       |y      |x AND y    |x OR y |not x\n",
    "|-------|-------|-----------|-------|-------\n",
    "True    |True   |True       |True   |False\n",
    "True    |False  |False      |True   |False\n",
    "False   |True   |False      |True   |True\n",
    "False   |False  |False      |False  |True\n",
    "\n",
    "Vamos aos exemplos. Fique à vontade para testar outras comparações, inclusive com mais de 2 condições.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo com operador 'and'\n",
    "a = 10\n",
    "b = 5\n",
    "c = 20\n",
    "(a > b) and (c > b)\n",
    "# Saída: True, pois ambas as expressões são verdadeiras (10 é maior que 5 E 20 é maior que 5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Outra forma do operador 'and'\n",
    "(a > b) & (c > b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo com operador 'or'\n",
    "# Observe\n",
    "False or False\n",
    "# Saída: False, pois ambas as expressões são falsas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Outra forma do operador 'or'\n",
    "True | False\n",
    "# Saída: True, pois pelo menos uma expressão é verdadeira\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo and and not\n",
    "\n",
    "not True | False\n",
    "# Saída: False, pois ambas as expressões são falsas\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡Para saber mais sobre operadores lógicos: https://docs.python.org/3/reference/expressions.html#boolean-operationshttps://docs.python.org/3/reference/expressions.html#boolean-operations"
   ]
  }
 ],
 "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.10.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}