03.Python Básico.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\" style=\"margin-top: 1em;\"><ul class=\"toc-item\"><li><span><a href=\"#Primeiros-passos-em-Python\" data-toc-modified-id=\"Primeiros-passos-em-Python-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Primeiros passos em Python</a></span><ul class=\"toc-item\"><li><span><a href=\"#Imprimindo-no-console\" data-toc-modified-id=\"Imprimindo-no-console-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Imprimindo no console</a></span></li><li><span><a href=\"#Variáveis-e-Tipos\" data-toc-modified-id=\"Variáveis-e-Tipos-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Variáveis e Tipos</a></span></li><li><span><a href=\"#Operadores\" data-toc-modified-id=\"Operadores-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Operadores</a></span><ul class=\"toc-item\"><li><span><a href=\"#Operadores-Matemáticos\" data-toc-modified-id=\"Operadores-Matemáticos-1.3.1\"><span class=\"toc-item-num\">1.3.1&nbsp;&nbsp;</span>Operadores Matemáticos</a></span></li><li><span><a href=\"#Precedência-de-Operadores\" data-toc-modified-id=\"Precedência-de-Operadores-1.3.2\"><span class=\"toc-item-num\">1.3.2&nbsp;&nbsp;</span>Precedência de Operadores</a></span></li><li><span><a href=\"#Exercícios\" data-toc-modified-id=\"Exercícios-1.3.3\"><span class=\"toc-item-num\">1.3.3&nbsp;&nbsp;</span>Exercícios</a></span></li><li><span><a href=\"#Operadores-que-atuam-sob-Strings\" data-toc-modified-id=\"Operadores-que-atuam-sob-Strings-1.3.4\"><span class=\"toc-item-num\">1.3.4&nbsp;&nbsp;</span>Operadores que atuam sob Strings</a></span></li><li><span><a href=\"#Comparações\" data-toc-modified-id=\"Comparações-1.3.5\"><span class=\"toc-item-num\">1.3.5&nbsp;&nbsp;</span>Comparações</a></span></li><li><span><a href=\"#Operadores-Lógicos\" data-toc-modified-id=\"Operadores-Lógicos-1.3.6\"><span class=\"toc-item-num\">1.3.6&nbsp;&nbsp;</span>Operadores Lógicos</a></span></li></ul></li><li><span><a href=\"#Conversões-de-tipo-(cast)\" data-toc-modified-id=\"Conversões-de-tipo-(cast)-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Conversões de tipo (cast)</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercicio:\" data-toc-modified-id=\"Exercicio:-1.4.1\"><span class=\"toc-item-num\">1.4.1&nbsp;&nbsp;</span>Exercicio:</a></span></li></ul></li><li><span><a href=\"#Entrada-de-dados-via-teclado\" data-toc-modified-id=\"Entrada-de-dados-via-teclado-1.5\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>Entrada de dados via teclado</a></span></li><li><span><a href=\"#Strings-literais-com-formatação\" data-toc-modified-id=\"Strings-literais-com-formatação-1.6\"><span class=\"toc-item-num\">1.6&nbsp;&nbsp;</span>Strings literais com formatação</a></span></li><li><span><a href=\"#A-função-format\" data-toc-modified-id=\"A-função-format-1.7\"><span class=\"toc-item-num\">1.7&nbsp;&nbsp;</span>A função format</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Primeiros passos em Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Imprimindo no console"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A função **print** é a responsável por imprimir uma representação textual no console"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Estudaremos as funções em profundidade mais a frente, mas, por enquanto, precisamos aprender apenas o suficiente sobre elas para usar a função de impressão. Como todas as funções, a sintaxe para a função de impressão começa com o nome da função (que neste caso é **print**), seguida de uma lista de argumentos, incluída entre parathensis ( ). Nós vimos a impressão chamada com um único argumento acima, no entanto, é possível imprimir vários arguments (qualquer número, de fato), separado por vírgulas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Hello\", \"world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Observe que vários argumentos podem ser passados para a função de impressão, separados por vírgulas. Um único espaço é colocado entre cada argumento na saída. Você pode redefinir o caracter que é colocado entre cada argumento. No exemplo abaixo foi usado o caracter nulo $\"\"$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Book\", \"mark\", sep=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ao final a função print irá imprimir o caracter de controle de mudança de linha \"\\n\". Portanto, para imprimir uma linha em branco, basta chamar a função print( ) sem argumentos. Você pode ainda redefinir o caracter de término da função print. No exemplo abaixo é usado um espaço apenas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print('You got', end=\" \")\n",
    "print('it!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variáveis e Tipos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* **int** - inteiros: ..., -3, -2, -1, 0, 1, 2, 3, ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = -3\n",
    "print(x, type(x))\n",
    "print(y, type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **float** - números reais (de ponto flutuante), frações de decimal: -3.2, 1.5, 1e-8, 3.2e5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 5.0\n",
    "y = -3.2\n",
    "z = 2.2e6\n",
    "print(x, type(x))\n",
    "print(z, type(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **str** - Strings (cadeia de caracteres) \n",
    " - letras, caracteres especiais, espaços, dígitos\n",
    " - entre aspas duplas ou aspas simples. Ex.: \"MC102\", 'python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = \"MC102.py\"\n",
    "y = 'I love python'\n",
    "print(x, type(x))\n",
    "print(y, type(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(type(4), type(4.0), type(\"4\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **bool** - Valores Boleanos: Verdadeiro (True) e Falso (False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "i_love_python = True\n",
    "python_loves_me = False\n",
    "print(i_love_python, type(i_love_python))\n",
    "print(python_loves_me, type(python_loves_me))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operadores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Operadores Matemáticos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Adição:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "4 + 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "4 + x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 4.0 + 5\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Subtração:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x - 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Multiplicação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Divisão - inteira (//) e divisão em ponto flutuante (/):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "10 // 3, 10 / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Potência:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "2 ** 3, 2 ** 3.0, 3 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Módulo (resto) da divisão inteira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "10 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Precedência de Operadores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Precedência é a ordem na qual os operadores serão avaliados quando o programa for executado. Em Python, os operadores são avaliados na seguinte ordem:\n",
    "\n",
    "- $**$\n",
    "- $*\\ $, $/\\ $, $//$, na ordem em que aparecerem na expressão.\n",
    "- $\\%$\n",
    "- $+\\ $, $-$, na ordem em que aparecerem na expressão."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Pode-se controlar a ordem com que as expressões são avaliadas com o uso de parênteses.\n",
    "\n",
    "$($ expressão $)$ também é uma expressão, que calcula o resultado da expressão dentro dos parênteses, para só então calcular o resultado das outras expressões:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(5 + 10 % 3)\n",
    "print((5 + 10) % 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Você pode usar quantos parênteses desejar dentro de uma expressão.\n",
    "Procure usar sempre parênteses em expressões para deixar claro em qual ordem a mesma é avaliada!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercícios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    " 1: Como vocês acham que o python avaliará as expressões abaixo? É o resultado que vocês esperavam?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(8 / 2 + 5 * 3)\n",
    "print(5 + 10 % 3)\n",
    "print(5 * 10 % 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "2: O que acontece se deixarmos de fora um operando?\n",
    "Por exemplo, se digitarmos `3 + * 5` em vez de` 3 + 4 * 5`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "3 + * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Operadores que atuam sob Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Podemos concatenar strings usando o operador $+$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"Hello\" + \" World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Podemos \"n-plicar\" Strings usando operador $*$ (star):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"Bye\" * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Strings vs. números:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "4 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"4\" + \"5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"4\" + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "4 + \"5\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Comparações"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "5 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "5 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "5 >= 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "4 >= 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "4 <= 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "5 == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "5 == 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "5 == \"5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "5 != 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "2 + 2 == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "2 => 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "x = \"abc\"\n",
    "y = 'abc'\n",
    "x == y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"abd\" > \"abc\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "'abc' > 'abcd'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Operadores Lógicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* negação (not):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(not True)\n",
    "a = 2 == 5\n",
    "print(not a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* e (and):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "False and False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* ou (or):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "True or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conversões de tipo (cast)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Use as funções `int()`, `float()`, and `str()` para converter entre tipos (nós iremos falar sobre *funções* mais à frente):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = \"6\"\n",
    "print(x, type(x))\n",
    "x = int(\"6\")\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "float(\"1.25\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "str(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "course = \"intro\" + str(2) + \"cs\"\n",
    "print(course)\n",
    "print(\"intro\", 2, \"cs\", sep=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercicio:\n",
    "3: Compute o valor do polinomio $y=ax^2+bx+c$ para $x=-2$, $x=0$, e $x=2$ usando $a=1$, $b=1$, $c=-6$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "x = 2\n",
    "a = 1\n",
    "b = 1\n",
    "c = -6\n",
    "y = a * x ** 2 + b * x + c\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Entrada de dados via teclado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Usamos a função `input` para ler dados inseridos pelo usuário:\n",
    "-  Imprime a string no console\n",
    "-  O usuário escreve algo e pressiona a tecla `<enter>`\n",
    "-  a função então vincula este valor a uma variável. Ex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "text = input(\"Type anything... \") \n",
    "print(5*text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A função `input` fornece uma string. Portanto devemos fazer um \"cast\" se quisermos trabalhar com números. Ex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "num = int(input(\"Type a number... \"))\n",
    "print(5*num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strings literais com formatação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Um literal de cadeia de caracteres formatada ou f-string é um string literal que é prefixado com 'f' ou 'F'. Essas strings podem conter campos de substituição, que são expressões delimitadas por chaves `{` e `}`. Enquanto outros strings literais sempre têm um valor constante, as strings formatadas são realmente expressões avaliadas em tempo de execução. Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "name = \"Marcio\"\n",
    "idade = 58\n",
    "f'Seu Professor se chama {name} e tem {idade} anos de idade'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Um uso interessante de literais com formatação é a possibilidade de definir, por exemplo, a precisão de números de ponto flutuante na saida do console, ou ainda a formatação que você deseja usar para o calendário. Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from math import pi\n",
    "\n",
    "print(pi)\n",
    "\n",
    "width = 8\n",
    "precision = 5\n",
    "print(f'{pi:{width}.{precision}}')\n",
    "print(f\"{pi:.5}\")\n",
    "\n",
    "import datetime\n",
    "\n",
    "today = datetime.date(year=2018, month=3, day=1)\n",
    "print(\"Data no formato Americano: \", today)\n",
    "print(f\"Data no formato Brasileiro: {today:%d/%m/%Y}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A função format\n",
    "\n",
    "A função **format** converte o valor de um objeto para uma representação textual \"formatada\", seguindo a especificação fornecida. A sintaxe e uso da função é o seguinte:\n",
    "\n",
    "```\n",
    "format(value[, spec])\n",
    "print(format(value, spec))\n",
    "```\n",
    "Existe toda uma mini-linguagem que descreve a especificação da formatação para diferentes tipos de objetos [aqui](https://docs.python.org/3.1/library/string.html#formatspec). Eis alguns exemplos de formatação para os objetos escalares `int` e `float` que vimos até agora:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "pi = 3.141592653589793\n",
    "print(format(pi, \"f\"))      # imprime um float com até 6 casas decimais (default)\n",
    "print(format(pi, \".2f\"))    # imprime um float truncando em 2 casas decimais\n",
    "print(format(pi, \"6.2f\"))   # float com 6 digitos e 2 casas decimais. Preenche de espaço a parte + significativa\n",
    "print(format(123, \"d\"))     # imprime um int na sua representação decimal\n",
    "print(format(123, \"x\"))     # idem, na sua representação hexadecimal"
   ]
  }
 ],
 "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"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "livereveal": {
   "theme": "solarized",
   "transition": "slide"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": true,
   "toc_position": {
    "height": "565px",
    "left": "0px",
    "right": "1068px",
    "top": "111px",
    "width": "212px"
   },
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}