02 - Variáveis e Tipos Básicos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variáveis e Tipos Básicos\n",
    "\n",
    "Uma das coisas mais famosas - tanto para o bem quanto para o mal - de Python é que não é necessário declarar variáveis. Nem seus tipos. Nem nada. Você simplesmente dá uma instrução de atribuição..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... e pronto! Temos uma variável x com o valor '10'.\n",
    "\n",
    "Isso não significa que Python aboliu a definição de tipos, muito pelo contrário. Os tipos ainda existem — como você deve ter imaginado, x é um inteiro, já vamos chegar nessa parte.\n",
    "\n",
    "A diferença é que o Python _inferiu_ o tipo com base no contexto. Você não precisou _declarar_ o tipo como faria em uma linguagem como C ou Java, onde seria necessário escrever algo do tipo `int x = 10;`\n",
    "\n",
    "Você pode inspecionar o tipo de uma variável usando o comando `type`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também alterar dinamicamente o tipo de uma variável:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = \"Banana\"\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os tipos embutidos na linguagem são [bem variados](https://docs.python.org/3/library/stdtypes.html). Ao longo do curso, exploraremos alguns deles. Nesse momento, vou me limitar aos tipos numéricos, booleanos e strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Números\n",
    "\n",
    "Existem três tipos nativos de números em Python - inteiros, números com ponto flutuante e números complexos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "salário_mínimo = 954\n",
    "cotação_dólar = 3.72\n",
    "raíz_quadrada_de_menos_um = 1j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_(Código em Português?! Com acento?? São duas coisas que causam estranheza muitas vezes. De fato, ao programar com a finalidade de desenvolver software, o usual é programarmos em Inglês. Vou tratar disso mais pra frente. Como estamos lidando com uma parte mais básica da linguagem, prefiro escrever o código no mesmo idioma que o resto do texto. Python desde a versão 3.0 aceita caracteres acentuados como nomes de identificadores)_\n",
    "\n",
    "Vamos inspecionar o tipo das três variáveis criadas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(salário_mínimo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(cotação_do_dólar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1+0j)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(raíz_quadrada_de_menos_um)\n",
    "raíz_quadrada_de_menos_um ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível realizar conversão (_casting_) entre os tipos utilizando seus nomes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para extrair as componentes de um número imaginário, é necessário usar propriedades `real` e `imag` do objeto criado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 + 1j).real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 + 1j).imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Detalhes sobre a precisão de floats](https://docs.python.org/3.1/tutorial/floatingpoint.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As operações usuais estão definidas:\n",
    "\n",
    "|Operação|Operador|Exemplo|\n",
    "|-----------|:---:|-------:|\n",
    "|Soma|+|`3 + 2 = 5`|\n",
    "|Subtração|-|`20 - 10 = 10`|\n",
    "|Divisão|/|`3 / 2 = 1.5`|\n",
    "|Div. Inteira|//|`5 // 2 = 2`|\n",
    "|Modulo \"resto\"|%|`5 % 3 = 2`|\n",
    "|Potência|\\*\\*|`10 ** 2 = 100`|\n",
    "|Val. Absoluto|`abs(x)`|`abs(-10) = 10`|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios\n",
    "\n",
    "Modifique os trechos de código a baixo para que eles retornem o valor desejado — execute-os (Shift + Enter) para verificar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# Armazene sua idade na variável a baixo e calcule o dobro\n",
    "idade = 0\n",
    "print(idade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# Some os 3 primeiros números ímpares\n",
    "soma = 0\n",
    "print(soma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# Eleve o número 2 à potência 64, na variável x\n",
    "x = 0\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Atribuições Aritméticas Expandidas\n",
    "\n",
    "É um nome chique pra quando a gente pode embutir o operador de atribuição \"`=`\" com operadores aritméticos. Por exemplo:\n",
    "\n",
    "```python\n",
    "x = 10\n",
    "x = x + 20\n",
    "```\n",
    "\n",
    "é a mesma coisa que:\n",
    "\n",
    "```python\n",
    "x = 10\n",
    "x += 20\n",
    "```\n",
    "\n",
    "Os operadores definidos são:\n",
    "\n",
    "|Operação|Operador|\n",
    "|-----------|:---:|\n",
    "|Soma|+=|\n",
    "|Subtração|-=|\n",
    "|Divisão|/=|\n",
    "|Div. Inteira|//=|\n",
    "|Modulo \"resto\"|%=|\n",
    "|Potência|\\*\\*=|\n",
    "\n",
    "O uso desses operadores pode ajudar a deixar o código mais limpo. Eles fazem exatamente a mesma coisa que o operador de atribuição acoplado com o da operação que você quer executar.\n",
    "\n",
    "**Exercício**: Eleve 10 ao quadrado usando o operador de atribuição expandida:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício** Some os números 1, 2, 3 e 4 na variável z utilizando o operador expandido:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pacotes nativos e aleatoriedade\n",
    "\n",
    "Python possui diversos [pacotes nativos](https://docs.python.org/3/py-modindex.html) que podem ser importados e utilizados usando a palavra chave `import`. Vamos testar o pacote [`random`](https://docs.python.org/3/library/random.html#module-random):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "import random  # Podemos importar o pacote todo\n",
    "print(random.randint(10, 30))  # E chamar suas funções internas usando a notação pacote.nome_da_função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "from random import randint  # Podemos também importar _apenas_ o que precisamos\n",
    "print(randint(0, 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "from random import randint as r  # Podemos dar apelido pras coisas que importamos\n",
    "print(r(2, 20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante notar que o módulo `random` não é adequado para situações em que aleatoriedade é usada para aplicações criptográficas. Se essa for sua necessidade, utilize o módulo `secrets`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booleanos\n",
    "\n",
    "Variáveis booleanas armazenam apenas \"verdadeiro\" ou \"falso\". Assim como as numéricas, essa atribuição pode ser direta ou através de expressões"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "x_é_par = x % 2 == 0  # Verifica se o resto da divisão de x por 2 é 0\n",
    "print(x_é_par)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os operadores booleanos `and`, `or` e `not` são definidos de forma explícita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Precedência e Curto-circuito\n",
    "\n",
    "E possuem a precedência `or`-> `and` -> `not`. A precedência pode ser alterada com parênteses. Os operadores `and` e `or` fazem curto-circuito. Observe:\n",
    "\n",
    "Uma expressão composta por \"ou\" só será falsa caso _ambos_ os argumentos sejam falsos. Ou seja, se o primeiro argumento é _verdadeiro_, o segundo argumento não precisa ser calculado!\n",
    "\n",
    "`True or qualquer_expressão_complexa` → **sempre será `True`!**\n",
    "\n",
    "De maneira análoga, uma expressão composta com \"e\" só será verdadeira caso _ambos_ os argumentos sejam **verdadeiros**. Dessa forma, se o primeiro argumento for _falso_, o segundo argumento não precisa ser computado também\n",
    "\n",
    "`False and qualquer_expressão` → **sempre será `False`**\n",
    "\n",
    "Python — assim como outras linguagens — decide por fazer um curto-circuito. Se você escrever uma expressão complexa que pode ser resolvida apenas pelo primeiro termo, o segundo termo jamais será acessado.\n",
    "\n",
    "[Referência](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or 10 / 0 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que essa expressão é composta por duas partes. A segunda parte é uma divisão por zero! Isso causa um erro no interpretador. Observe essa expressão sozinha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-cd759d3fcf39>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m10\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "10 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No entanto, na expressão `True or 10 / 0` esse erro não ocorre pois Python faz um curto-circuito e calcula a expressão com base apenas no primeiro argumento. Afinal, independente do que viria em seguida, a resposta seria `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False or False  # O que está acontecendo aqui? Coloque parênteses para deixar a expressão True!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Faça uma instrução com and e 10 / 0 que utilize de curto circuito de forma que nenhum erro aconteça\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Casting para booleano\n",
    "\n",
    "Em alguns momentos é necessário — ou simplesmente é mais legível — explicitar que uma conversão de tipos é necessária. Como em diversas linguagens, True equivale ao inteiro 1 e False, 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True + True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True * False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que nos dois exemplos, Python converteu implicitamente os valores booleanos para um valor inteiro — o valor que é necessário para realizar essas operações. Apesar da sintaxe permitir operações assim, eu recomendo que um _casting_ explícito seja feito. O código fica mais fácil de ser lido e compreendido por todos — até mesmo aqueles que não são iniciados nas magias negras do Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(True) + int(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(True) * int(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De maneira análoga, é possível fazer um _casting_ para booleano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apenas 0 é considerado `False`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings vazias também \"são falsas\", assim como listas, sets, dicionários. Todos esses conceitos serão abordados posteriormente!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(\"\")  # String vazia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(\"batata\")  # String qualquer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool([])  # Lista vazia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool([1, 2, 3, 4])  # Lista qualquer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool({})  # Dicionário Vazio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool({\"nome\": \"Stairway to Python\"})  # Dicionário qualquer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(set())  # Set vazio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(set([1, 2, 3]))  # Set qualquer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores de Comparação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os [operadores comuns](https://docs.python.org/3/library/stdtypes.html#comparisons) de comparação de tamanho e igualdade são definidos junto com operadores de identidade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 >= 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 <= -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma característica interessante de Python é que esses operadores podem ser encadeados de forma natural"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 < 20 < 30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essa expressão é equivalente à:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 < 20 and 20 < 30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que **existe um `and` implícito nesse encadeamento**! Ele também sofre curto-circuito. Vamos colocar uma expressão falsa de um lado e uma expressão inválida do outro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 > 20 > 2 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essa expressão equivale a:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(10 > 20) and (20 > 2 / 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como o lado esquerdo é `False` e estamos usando um `and`, o resultado dessa expressão será `False`, independente do valor de `20 > 2 / 0`. Na verdade, calcular essa expressão resultaria num erro de divisão por zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-71-47318d74bc0c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m20\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "20 > 2 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém, graças ao curto-circuito do operador `and`, esse erro não aconteceu! Muitas vezes existem \"bugs silenciosos\" em software — porções de código que estão formalmente incorretas mas que por conta de circunstâncias ou da mecânica global do programa, nunca são executadas e seu comportamento errado nunca é executado ou nunca é sentido."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checando coisas com `assert`\n",
    "\n",
    "Muitas vezes precisamos — e devemos! — checar partes do estado interno de nosso código e interromper o funcionamento caso alguma coisa estranha aconteça. Com a expressão `assert` podemos fazer isso sem escrever estruturas mais complicadas. A sintaxe é a que segue:\n",
    "\n",
    "```python\n",
    "assert expressão_booleana, \"mensagem opcional caso a expressão seja falsa\"\n",
    "```\n",
    "\n",
    "Vamos ver alguns exemplos na prática:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert True  # nada acontece, true é true!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-7a11a91eb024>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[1;32mFalse\u001b[0m  \u001b[1;31m# Aqui temos problema!\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "assert False  # Aqui temos problema!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que ele nos deu uma exceção do tipo `AssertionError` e sem nenhuma mensagem. Essa mensagem somos nós que podemos colocar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "O ano precisa ser 2018!",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-e29a34aa75ee>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mano\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2010\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mano\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m2018\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"O ano precisa ser 2018!\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m: O ano precisa ser 2018!"
     ]
    }
   ],
   "source": [
    "ano = 2010\n",
    "\n",
    "assert ano == 2018, \"O ano precisa ser 2018!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "Você precisa fornecer um nome!",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-2b69e94c1875>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mnome\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mnome\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[1;34m\"\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"Você precisa fornecer um nome!\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m: Você precisa fornecer um nome!"
     ]
    }
   ],
   "source": [
    "nome = \"\"\n",
    "assert nome != \"\", \"Você precisa fornecer um nome!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}