ipynb/Capitulo-03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Capítulo 03 - Expressões Lógicas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Várias instruções dependem do resultado de comparações (ou condições) de tipo x > y (x é maior que y).\n",
    "O resultado de uma condição é verdadeiro ou falso. Uma comparação só pode ser feita entre pares de elementos, assim, para criar condições mais complexas é necessário utilizar **expressões lógicas**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.1.  Expressões booleanas\n",
    "\n",
    "Uma expressão booleana é uma expressão que é verdadeira **(True)** ou falsa **(False)**. Em python, uma expressão que é verdadeira tem o valor 1, uma expressão que é falsa tem o valor 0.\n",
    "\n",
    "O operador `==` compara dois valores e produz uma expressão booleana."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 == 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 == 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.2. Operadores de Comparação  (Relacionais)\n",
    "\n",
    "Os principais **operadores de comparação** ou (Operadores Relacionais):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- **> Maior que.**\n",
    "- **>= Maior igual.**\n",
    "- **< Menor que.**\n",
    "- **<= Menor igual.**\n",
    "- **!= Diferente de.**\n",
    "- **== Igual a.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Outros **operadores de comparação**, são:\n",
    "\n",
    "- **in.**\n",
    "- **not in.**\n",
    "- **is.**\n",
    "- **is not.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 40\n",
    "texto = 'banana'\n",
    "lista = [1, 2, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador Maior que\n",
    "x > y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador Maior igual\n",
    "x >= y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador Menor que\n",
    "x < y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador Menor igual\n",
    "x <= y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador Diferente de\n",
    "x != texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador iqual a\n",
    "x == 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x não está na lista!\n"
     ]
    }
   ],
   "source": [
    "# Operador in\n",
    "if x in lista:\n",
    "    print(\"x está na lista!\")\n",
    "else:\n",
    "    print(\"x não está na lista!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x não está na lista!\n"
     ]
    }
   ],
   "source": [
    "# Operador not in\n",
    "if x not in lista:\n",
    "    print(\"x não está na lista!\")\n",
    "else:\n",
    "    print(\"x está na lista!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador is\n",
    "x is 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador de negação is not\n",
    "10 is not 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.3. Operadores Lógicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Existem três **operadores lógicos**: and, or e not `e`, `ou` e `não`. A semântica (significado) destes operadores é similar aos seus significados em inglês (ou português)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Por exemplo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Exemplo 1:**\n",
    "```python\n",
    "x > 0 and x < 10\n",
    "```\n",
    "\n",
    "É verdadeiro somente se x for maior que 0 e menor que 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplo 2:**\n",
    "```python\n",
    "n % 2 == 0 or n % 3 == 0\n",
    "```\n",
    "\n",
    "É verdadeiro se qualquer condição for verdadeira, que dizer que se o número `n` for divisivel por 2 ou por 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Exemplo 3:**\n",
    "\n",
    "```python\n",
    "not(x > y)\n",
    "```\n",
    "É falso se a condição for verdadeira. Simplesmente nega a condição."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo 1\n",
    "5 > 0 and 5 < 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo 2\n",
    "4 % 2 == 0 or 4 % 3 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exemplo 3\n",
    "not(10 > 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.4. Operadores bit-a-bit (Bitwise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Operadoes bit-a-bit (Bitwise) ou (\"escovar bits\"). É uma tecnica que usar alguns operadores para alterar uma sequência de bits de uma variável."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Esses operadores são:**\n",
    "\n",
    "- **x << y:** Deslocamento bit-a-bit para a esquerda.\n",
    "- **x >> y:** Deslocamento bit-a-bit para direita.\n",
    "- **x & y:** Operador bit-a-bit AND.\n",
    "- **x | y:** Operador bit-a-bit OR.\n",
    "- **x ^ y:** Operador bit-a-bit XOR.\n",
    "- **~x:** Operador bit-a-bit NOT."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Decimal**|**Binário**|**Hexadecimal**\n",
    ":--:|:--:|:--:\n",
    "0|0000|0\n",
    "1|0001|1\n",
    "2|0010|2\n",
    "3|0011|3\n",
    "4|0100|4\n",
    "5|0101|5\n",
    "6|0110|6\n",
    "7|0111|7\n",
    "8|1000|8\n",
    "9|1001|9\n",
    "10|1010|**A**\n",
    "11|1011|**B**\n",
    "12|1100|**C**\n",
    "13|1101|**D**\n",
    "14|1110|**E**\n",
    "15|1111|**F**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 1  # equivalente em binário 0001"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Os operadores `<<` e `>>` fazem o deslocamento dos bits para direita e para esquerda. Preenchendo o restante com 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Deslocamento de bits para a esquerda\n",
    "x << 2  # resultado é 4 que equivale à 0100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Deslocamento de bits para direita\n",
    "x >> 2  # resultado é 0, que equivale à 0000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### O operador `&` compara os bits de cada variável um por um, quando os dois bits (de uma variável e de outra variável), são iguais a  1 (bit ligado), o retorno é 1. Caso contrário, ele é 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador bit-a-bit AND\n",
    "x & 1  # resultado é 1, que equivale à 0001"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### O operador `|` também compara  os bits de cada variável um por um, quando pelo menos um dos bits é igual a 1, o retorno é 1. Caso contrário, ele é 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador bit-a-bit OR\n",
    "x | 2  # resultado é 3, que equivale à 0011"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### O operador `^` compara os bits de forma  que se, os 2 bits (de uma variável e de outra variável) forem iguais ele, retorna 0. Caso contrário, retorna 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador bit-a-bit XOR\n",
    "x ^ 2  # resultado é 3, que equivale à 0011"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### O operador `~` inverte os bits  de uma variável, onde era 1 fica 0 e onde era 0, fica 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operador bit-a-bit NOT\n",
    "~x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 3.5. Operadores Condicionais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Operadores condicionais são utilizados quando é necessário fazer uma determinada verificação. Ou, seja, checar se aquela condição é verdadeira ou não. Quase sempre precisamos checar essa condição, para mudar o comportamento do programa de acordo com a necessidade. A forma mais simples que utilizamos é o `if` **(se)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplo 1:**\n",
    "```python\n",
    "x = 10\n",
    "if x > 0:\n",
    "    print(\"%s é positivo!\" % x)\n",
    "else:\n",
    "    print(\"%s é negativo!\" % x)\n",
    "```\n",
    "Denominamos o exemplo 1, como **seleção binária**, pois adimite apenas dois possíveis caminhos de execução.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exemplo pseudocódigo:**\n",
    "```portugol\n",
    "numero = 10\n",
    "se 2 % numero == 0 então:\n",
    "    escreva('O número é par!')\n",
    "senão:\n",
    "  escrevra('O número é impar!')  \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 é positivo!\n"
     ]
    }
   ],
   "source": [
    "# Exemplo 1\n",
    "x = 10\n",
    "if x > 0:\n",
    "    print(\"%s é positivo!\" % x)\n",
    "else:\n",
    "    print(\"%s é negativo!\" % x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O número 10 é impar!\n"
     ]
    }
   ],
   "source": [
    "# Exemplo 2\n",
    "numero = 10\n",
    "if 2 % numero == 0:\n",
    "    print(\"O número %s é par!\" % numero)\n",
    "else:\n",
    "    print(\"O número %s é impar!\" % numero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 3.5.1. Condicionais Aninhados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Podemos ter condicionais **aninhados**, um dentro do outro.\n",
    "\n",
    "```python\n",
    "if x == y:\n",
    "    print(\"%s e %s são iguais\" % (x, y))\n",
    "else:\n",
    "    if x < y:\n",
    "        print(\"%s é menor %s\" % (x, y))\n",
    "    else:\n",
    "        print(\"%s é maior que %s! % (x, y))\n",
    "```\n",
    "O condicional mais externo tem dois ramos. O primeiro ramo também contém uma única saída. O segundo ramo contém outra instrução `if`, que por sua vez tem dois ramos. Os dois ramos são ambos instruções de saída, embora pudessem conter instruções condicionais também."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Exemplo:\n",
    "```python\n",
    "if x < y:\n",
    "    print(\"%s é menor que %s\" % (x, y))\n",
    "else:\n",
    "    if x > y:\n",
    "        print(\"%s é maior que %s\" % (x, y))\n",
    "    else:\n",
    "        print(\"%s e %s são iguais\" % (x, y))       \n",
    "```\n",
    "\n",
    "O condicional externo tem duas ramificações. A segunda ramificação (o else externo) contém outro comando `if`, o qual tem outras duas ramificações. Essas duas ramificações podem também conter comandos condicionais.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Obs:** Embora a endentação das instruções torne a estrutura aparente, condicionais aninhados tornam-se difíceis de ler rapidamente. Em geral, é uma boa **ideia**, evitar o aninhamento quando for possível."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 é maior que 10!\n"
     ]
    }
   ],
   "source": [
    "# Exemplo 1\n",
    "x = 15\n",
    "y = 10\n",
    "\n",
    "if x == y:\n",
    "    print(\"%s e %s são iguais\" % (x, y))\n",
    "else:\n",
    "    if x < y:\n",
    "        print(\"%s é menor %s\" % (x, y))\n",
    "    else:\n",
    "        print(\"%s é maior que %s!\" % (x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 é maior que 10\n"
     ]
    }
   ],
   "source": [
    "# Exemplo 2\n",
    "if x < y:\n",
    "    print(\"%s é menor que %s\" % (x, y))\n",
    "else:\n",
    "    if x > y:\n",
    "        print(\"%s é maior que %s\" % (x, y))\n",
    "    else:\n",
    "        print(\"%s e %s são iguais\" % (x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 3.5.2. Condicionais Encadeados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Além da opção por aninhar condicionais. Também podemos utilizar a forma **encadeada de condicionais**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python\n",
    "if x < y:\n",
    "    print(\"x  é menor que y.\")\n",
    "elif x > y:\n",
    "    print(\"x é maior que y.\")\n",
    "else:\n",
    "    print(\"x e y são iguais.\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`elif` é uma abreviação de `else` e `if`. Não há limites do número de `elif`, mas apenas um simples (e opcional) `else` final é permitido e precisa ser  a última ramificação do comando.\n",
    "Cada condição é verificada em ordem. Se a primeira é falsa, a próxima é então verificada, e assim por diante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x e y são iguais.\n"
     ]
    }
   ],
   "source": [
    "# Exemplo em execução\n",
    "x = 10\n",
    "y = 10\n",
    "\n",
    "if x < y:\n",
    "    print(\"%s é menor que %s.\" % (x, y))\n",
    "elif x > y:\n",
    "    print(\"%s é maior que %s.\" % (x, y))\n",
    "else:\n",
    "    print(\"x e y são iguais.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tabela de Precedência de Operadores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "A tabela abaixo mostra a precedência dos operadores em Python, da mais baixa para mais alta. Isto significa que, em uma expressão, será avaliado primeiro os operadores mais baixos desta tabela antes dos operadores mais acima.\n",
    "Essa tabela também se encontra na documantação oficial, em [Operator precedence](https://docs.python.org/3/reference/expressions.html#operator-precedence)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<div align='center'>\n",
    "    <img src='../images/figura_3.1.png'/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div align='center'>\n",
    "   <a href='../ipynb/Capitulo-02.ipynb#/slide-0-0' style=\"padding-right: 2em;\"><i class=\"fa fa-angle-double-left\"></i> Básico de Python</a>\n",
    "   <a href='../ipynb/Capitulo-04.ipynb#/slide-0-0'>Loops <i class=\"fa fa-angle-double-right\"></i></a>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}