01-python-intro/aula-02/Aula 02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Py-Intro] Aula 02\n",
    "# Tipos básicos e estruturas de controles\n",
    "\n",
    "## O que você vai aprender nesta aula?\n",
    "\n",
    "Após o término da aula você terá aprendido:\n",
    "\n",
    "- Números e expressões aritméticas\n",
    "- Strings\n",
    "- Estruturas de controles de fluxo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos básicos\n",
    "\n",
    "São chamados de tipos básicos aqueles que vem embutidos na própria linguagem, são eles: tipos núméricos, sequências, mapeamentos, classes, instâncias e exceções (esses três últimos serão vistos no curso de `Orientação a Objetos em Python`). Vamos começar pelos tipos numéricos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos numéricos - int, float e complex\n",
    "\n",
    "Existem três tipos diferentes de números: inteiros, números de ponto flutuante e números complexos. Números são obtidos a partir de declarações ou operações aritméticas.\n",
    "\n",
    "Números inteiros possuem precisão \"ilimitada\", ou seja, podem, em teoria, ter infinitas casas decimais. Números de ponto flutuante são implementados usando o tipo `double` em C e sua precisão pode variar de acordo com a máquina que roda o programa. Números complexos possuem uma parte real e imaginária e ambas são números de ponto flutuante\n",
    "\n",
    "O interpretador do Python e - por consequência cada célula de código do Jupyter Notebook - funciona como uma calculadora, assim podemos mostrar o funcionamento desses números na prática:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "20 + 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 * 8 - 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5 * 8 - 10) / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 / 5  # o resultado da divsião sempre é um float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Os números inteiros (como 20, 13, 33 e 30) possuem tipo `int`, enquanto os que possuem a parte fracional (como 10.0 e 1.6) são `float`.\n",
    "\n",
    "Para verificar o tipo deve ser usada a função `type()` que é utilizada assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O python também suporta os seguinte operadores:\n",
    "- `//` divisão inteira\n",
    "- `%` resto da divisão inteira\n",
    "- `**` potenciação\n",
    "\n",
    "Seu uso é demonstrado a seguir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.333333333333333"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "16 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "16 // 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "16 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 * 3 + 1  # resultado * divisor + resto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "407254001651377825050774086265365912933271559572398924650169906751889900030955189004916347478470698880616885512201849445183728845558993514870858509087817789576388584560964682795896403435448681980001360244790530805842737419978616650940647045809688543958807077794866143976192872389017280782837244051514550016751431331392474612723898201318251801288569103581859710953756463227568553903785400053293756105145991925711692828410365978814157929143646138367222515290495329841814490874087309733954914817582614165290441834984054374534909954119315442169415884429645515258867781282214407424938115130906555866837546110340314133204645184212592152733050063403478054121909337278892530383627259086060904403894148963384111173869448637825223750221720739904084905206403076141255284819817001128530851921214720479861908207168928806625713775441834487646542035428141369478170696522098960677314242891140325390964310295889079588950798788612324634050495786532200848059999839607732520233"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(10 ** 800 + 9 ** 1000) * 233  # Olha, mãe! Números gigantes sem as bibliotecas!1!!1!111!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os números também podem ser representados em razão a sua potência na base 10 dessa forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1e2  # equivale a 10 ^ 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.01"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1e-2  # equivale a 10 ^ -2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Geralmente essa notação é ativada automaticamente para números muito pequenos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1e-07"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / 10000000  # 0.0000001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0967741935483873e-07"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "127 / 310000000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Tome cuidado ao realizar divisões, pois divisão por 0 levanta uma exceção:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-3e699e72a4ab>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m10\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "10 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Python não possui os operadores `++` e `--`, para incrementar ou decrementar números faça:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = 0\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i += 1\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i += 1\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i -= 1\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso também funciona para outros operadores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero = 100\n",
    "numero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero /= 5\n",
    "numero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "400.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero *= 20\n",
    "numero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "375.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero -= 25\n",
    "numero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "53.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero //= 7\n",
    "numero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2809.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero **= 2\n",
    "numero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Os números complexo são criados da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1+3j)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 3j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1 + 3j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E também permitem operações aritméticas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3+4j)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 + 3j) + (5 - 1j) - (3 - 2j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para realizar operações mais avançadas existe dentro do Python a biblioteca [math](https://docs.python.org/3/library/math.html) que possuim funções para calcular:\n",
    "- Teto e chão\n",
    "- Fatorial\n",
    "- Log e exponencial\n",
    "- Potenciação e raiz quadrada\n",
    "- Funções trigonométricas\n",
    "- Constantes como $\\pi$ (pi) e $\\mathrm{e}$ (constante de Euler)\n",
    "\n",
    "Para utilizar essas funções precisamos importar essa biblioteca:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.141592653589793, 2.718281828459045)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi, math.e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.floor(math.pi)  # chão"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.ceil(math.pi)  # teto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(math.e ** 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log10(10 ** 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "148.4131591025766"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.exp(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1023.9488011519843"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pow(1.99999, 10)  # math.pow é recomendado para se trabalhar com números de ponto flutuante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.9999999999999998"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(3.999999999999999)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios\n",
    "\n",
    "##### Exercício 1\n",
    "Sabendo que a área de uma circunferência é calculada pela fórmula a seguir (sendo `A` a área e `r` o raio):\n",
    "\n",
    "$a = \\pi * r ^ 2 $\n",
    "\n",
    "Complete a seguinte função (usando a biblioteca math) para calcular a circunferência de um círculo dado um raio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def area_circulo(raio):\n",
    "    area = ...\n",
    "    return area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Não mude as próximas linhas!\n",
    "# Elas servem para testar se seu código funciona :-)\n",
    "assert area_circulo(7.93115399705473) == 197.61624270971336\n",
    "assert area_circulo(38.68203836108609) == 4700.765375865766\n",
    "assert area_circulo(64.88921270604881) == 13228.021209431301\n",
    "assert area_circulo(94.11113713755829) == 27824.79124198601\n",
    "assert area_circulo(99.77934573034769) == 31277.438328220036"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercício 2\n",
    "Implemente uma função que calcule os encargos trabalhistas dado um salário, sabendo que são descontados:\n",
    "- 11% para o Imposto de Renda\n",
    "- 8% para o INSS\n",
    "- 5% para o sindicato\n",
    "\n",
    "A função deve imprimir:\n",
    "\n",
    "- Salário bruto e líquido\n",
    "- Quanto foi pago INSS\n",
    "- Quanto foi pago ao sindicato"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def calcula_encargos(salario):\n",
    "    imposto_renda = ...\n",
    "    valor_INSS = ...\n",
    "    valor_sindicato = ...\n",
    "    salario_liquido = ...\n",
    "    \n",
    "    # não precisa mexer daqui para baixo!\n",
    "    # A impressão dos dados calculados já está pronta! :-)\n",
    "    FORMATO = (\n",
    "        \"+ Salário Bruto:   R$ {salario:.2f}\\n\"\n",
    "        \"- IR(11%)      :   R$ {imposto_renda:.2f}\\n\"\n",
    "        \"- INSS(8%)     :   R$ {valor_INSS:.2f}\\n\"\n",
    "        \"- Sindicato(5%):   R$ {valor_sindicato:.2f}\\n\"\n",
    "        \"= Salário Líquido: R$ {salario_liquido:.2f}\\n\"\n",
    "    )\n",
    "    print(FORMATO.format(salario=salario, imposto_renda=imposto_renda,\n",
    "                         valor_INSS=valor_INSS, valor_sindicato=valor_sindicato,\n",
    "                         salario_liquido=salario_liquido))\n",
    "\n",
    "\n",
    "# imprime os encargos dos salário de 1000, 1500, 2000, ..., 5000\n",
    "salarios = range(1000, 5001, 500)\n",
    "for salario in salarios:\n",
    "    calcula_encargos(salario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No Python 3 todas as strings são representadas por caracteres Unicode e o encoding padrão é UTF-8. Tá, mas o que isso quer dizer? Na prática a adoção desses padrões resolvem a maior parte dos problemas de codificação de caracteres. Acentos, caracteres das línguas chinesas, coreanas são representados sem dor de cabeça. Para entender melhor como isso funciona olhe [esta página](https://docs.python.org/3/howto/unicode.html).\n",
    "\n",
    "Strings em python podem ser representadas de diferentes maneiras:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sou uma string!11!11!!!'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Sou uma string!11!11!!!'  # aspas simples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ela é uma string!?'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ela é uma string!?\"  # aspas duplas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'这是一个字符串'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'这是一个字符串'  # UTF-8 é maravilhindo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'😸😹😺'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'😸😹😺'  # tem até gatinhos sorrindo, como não gostar?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para exibir aspas simples dentro de uma string definida por aspas simples use `\\`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"É preciso ter cuidado com 'aspas'\""
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'É preciso ter cuidado com \\'aspas\\''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou você pode simplesmente definí-las com aspas duplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"É preciso ter cuidado com 'aspas'\""
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"É preciso ter cuidado com 'aspas'\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O inverso também é valido:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ele disse: \"É preciso ter cuidado com aspas\"'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ele disse: \\\"É preciso ter cuidado com aspas\\\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ele dise: \"É preciso ter cuidado com aspas\"'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Ele dise: \"É preciso ter cuidado com aspas\"'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s = 'Primeira linha.\\nSegunda linha.'  # \\n representa uma quebra de linha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Primeira linha.\\nSegunda linha.'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s  # sem usar a função print() o \\n aparece na saída"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primeira linha.\n",
      "Segunda linha.\n"
     ]
    }
   ],
   "source": [
    "print(s)  # com print() o \\n produz uma quebra de linha"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você não quiser que caracteres começados com `\\` sejam tratados como caracteres especiais você pode usar `strings brutas` (*raw strings*). Isso é feito adiciona um `r` antes da primeira aspa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\u0007lgum\n",
      "ome\n"
     ]
    }
   ],
   "source": [
    "print('C:\\algum\\nome')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\algum\\nome\n"
     ]
    }
   ],
   "source": [
    "print(r'C:\\algum\\nome')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Raw strings facilitam o uso de expressões regulares.*\n",
    "\n",
    "Para especificar strings com mais de linha é recomendado usar aspas trilas: `\"\"\"...\"\"\"` ou `'''...'''`. Quebras de linha são adicionadas automaticamente, porém podem ser ignoradas com `\\`, conforme o seguinte exemplo: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex\n",
      "...\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"\\\n",
    "The Zen of Python, by Tim Peters\n",
    "\n",
    "Beautiful is better than ugly.\n",
    "Explicit is better than implicit.\n",
    "Simple is better than complex\n",
    "...\\\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings podem ser concatenadas de duas maneiras.\n",
    "\n",
    "Com o operador `+` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Py' + 'thon'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com duas strings (somente as envoltas por aspas) do lado da outra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Py' 'thon'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta concatenação não funciona com variáveis ou expressões:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-55-f81515de965d>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-55-f81515de965d>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    prefixo 'thon'\u001b[0m\n\u001b[1;37m                 ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "prefixo = 'Py'\n",
    "prefixo 'thon'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-56-baf11e42f8f8>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-56-baf11e42f8f8>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    ('Py' + 'thon') '!!!'\u001b[0m\n\u001b[1;37m                        ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "('Py' + 'thon') '!!!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso também pode ser usado para quebrar strings longas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'É possível colocar várias strings em parenteses para elas se juntarem'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto = ('É possível colocar várias strings em parenteses '\n",
    "         'para elas se juntarem')\n",
    "texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings podem ser repetidas com o uso do operador `*`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Créu Créu Créu Créu Créu Créu Créu Créu Créu Créu '"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Créu ' * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "É possível colocar várias strings em parenteses para elas se juntarem\n",
      "É possível colocar várias strings em parenteses para elas se juntarem\n",
      "É possível colocar várias strings em parenteses para elas se juntarem\n",
      "É possível colocar várias strings em parenteses para elas se juntarem\n",
      "É possível colocar várias strings em parenteses para elas se juntarem\n",
      "\n"
     ]
    }
   ],
   "source": [
    "textão = (texto + '\\n') * 5  # no Python 3 é possível criar variáveis com acentos!\n",
    "print(textão)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings podem ser acessadas pelo seu índice, com o primeiro caracter possuindo índice `0`. No Python não existe um tipo específico para caracter, um caracter é simplesmente uma string de tamanho 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra = 'Python'\n",
    "palavra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os índices podem ser negativos e acessam a sequência da direita para a esquerda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[-1]  # acessando o último índice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[-2]  # penúltimo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[-6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além de índices o Python também suporta fatiamento (*slicing*). O fatiamento oferece uma maneira simples de acessar substrings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Py'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[:2]  # pega os caracteres da posição 0 (incluído) até 2 (excluído)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'on'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[4:]  # pega os caracteres da posição 4 (incluído) até o final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'on'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[-2:]  # pega os caracteres da \"segunda última\" até o final"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para lembrar como funciona slicing funciona é pensar que os índices apontam para o índices `entre` os caracteres, como por exemplo:\n",
    "\n",
    "     +---+---+---+---+---+---+\n",
    "     | P | y | t | h | o | n |\n",
    "     +---+---+---+---+---+---+\n",
    "     0   1   2   3   4   5   6\n",
    "    -6  -5  -4  -3  -2  -1\n",
    "    \n",
    "Tentar acessar um índice maior que o tamanho da string resulta em um erro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-69-d9118a6caf77>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpalavra\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1500\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "palavra[1500]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas um fatiamento não:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'on'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[4:1500]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[1500:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings são imutáveis, para obter uma nova string é necessário criar uma nova:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-72-5a8e54da3e84>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpalavra\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'J'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "palavra[0] = 'J'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jython'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'J' + palavra[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pypy'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palavra[:2] + 'py'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lembrando que para saber o tamanho da string use a função `len()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(palavra)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'Pneumoultramicroscopicossilicovulcanoconioticos'\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como string são sequências é possível iterar seus caracteres assim como fazemos com a lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for caracter in palavra:\n",
    "    print(caracter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível iterar usando `while` para iterar por índices, apesar de o `while` não ser a melhor forma de fazer isso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S\n",
      "a\n",
      "u\n",
      "d\n",
      "a\n",
      "d\n",
      "e\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "s = 'Saudades'\n",
    "i = 0\n",
    "while i < len(s):\n",
    "    print(s[i])\n",
    "    i += 1\n",
    "# não faça isso"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você realmente precisar acessar os índices - o que acontece em algumas raras vezes - é possível iterar por índices usando `for` e a função `range()` como demonstrado a seguir\n",
    "\n",
    "*Na **grande maioria** dos casos não é necessário acessar os índices diretamente*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\n",
      "e\n",
      "c\n",
      "e\n",
      "s\n",
      "s\n",
      "i\n",
      "t\n",
      "o\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "s = 'Necessito!'\n",
    "for i in range(len(s)):\n",
    "    print(s[i])\n",
    "# use somente quando necessário"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercicio\n",
    "\n",
    "Crie o código que corrija as seguintes strings com o uso de substrings. (sem redefinir as strings):\n",
    "\n",
    "Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Farofa'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string = 'Fafofa'  # Farofa\n",
    "string[:2] + 'r' + string[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "string = 'Phython'  # Python\n",
    "...  # digite o código aqui"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "string = 'Gambiara'  # Gambiarra\n",
    "...  # digite o código aqui"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "string = 'Mundo Olá,'  # Olá, Mundo\n",
    "...  # digite o código aqui"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funcões úteis de strings\n",
    "\n",
    "`string.capitalize()` - Transformar o primeiro caracter para caixa alta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'José'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nome = 'josé'\n",
    "nome.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verificar se uma substring faz parte da string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nome = 'José Pereira da Silva'\n",
    "'Pereira' in nome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Silveira' in nome"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`string.lower()` - transformar todos os caracteres para caixa baixa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aaaaaaaaaaaaaaaaaaaaaaaaah!'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grito = 'AAAAAAAAAAAAAAAAAAAAAAAAAH!'\n",
    "grito.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`string.upper()` - transformar todos os caracteres para caixa alta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABC'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigla = 'abc'\n",
    "sigla.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`string.split(separador)` - retorna uma lista das palavras divididas pelo separador:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Pegando',\n",
       " 'cada',\n",
       " 'palavra',\n",
       " 'desta',\n",
       " 'frase',\n",
       " 'e',\n",
       " 'colocando-as',\n",
       " 'em',\n",
       " 'uma',\n",
       " 'lista']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frase = 'Pegando cada palavra desta frase e colocando-as em uma lista'\n",
    "lista = frase.split(' ')\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', '3', '4', '5', '6', '7', '8']"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros = '1-2-3-4-5-6-7-8'\n",
    "lista2 = numeros.split('-')\n",
    "lista2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`separador.join(lista)` - concatenas os elementos da lista separador pelo separador:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fazendo o caminho inverso do split'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = ['Fazendo', 'o', 'caminho', 'inverso', 'do', 'split']\n",
    "' '.join(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 * 2 * 3 * 4 * 5 * 6 * 7 * 8'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = ['1', '2', '3', '4', '5', '6', '7', '8']\n",
    "' * '.join(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`string.count(substring)` - conta quantas ocorrências de substring existem na string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'créu créu créu créu créu créu créu créu créu'.count('créu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frase = 'Essa frase não significa nada, não perca seu tempo lendo. Só vou contar quantos não eu escrevi aqui'\n",
    "frase.count('não')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "creu = 'Créu créu créu Créu créu créu créu Créu créu'\n",
    "creu.count('créu')  # count é sensível a caixa (case-sensitive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "creu = 'Créu créu créu Créu créu créu créu Créu créu'\n",
    "creu.lower().count('créu')  # normaliza a string para caixa baixa antes da contagem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`string.replace(antigo, novo[, maxreplace])` - realiza a troca de ocorrência da substring antiga pela nova, `maxreplace` vezes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Segura o tchan créu créu créu créu créu créu créu créu'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "creu = 'créu créu créu créu créu créu créu créu créu'\n",
    "tchan = creu.replace('créu', 'Segura o tchan', 1)\n",
    "tchan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Segura o tchan amarra o tchan, segura o créu créu créu créu créu créu créu'"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tchan.replace('créu', 'amarra o tchan, segura o', 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Segura o tchan tchan tchan tchan tchan tchan tchan tchan tchan'"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tchan.replace('créu', 'tchan')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depois desses exemplos eu declaro essa aula terminada, mas não antes de exercícios:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercicios\n",
    "\n",
    "- Complete a seguinte função que conta quantas vogais há na string recebida e retorna o total de todas as quantidades somadas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def conta_vogais(string):\n",
    "    vogais = 'aeiou'\n",
    "    total = 0\n",
    "    ... # normaliza a string\n",
    "    for vogal in vogais:\n",
    "        ...  # conta ocorrências\n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# o código abaixo serve para testar a corretude do programa\n",
    "assert conta_vogais('Camila Melo') == 5\n",
    "assert conta_vogais('Loteamento Dias, 73 - Cardoso - 14713-611 Fernandes de Ribeiro / RO') == 19\n",
    "assert conta_vogais('Pedro Miguel Araújo') == 8\n",
    "assert conta_vogais('Residencial Lorena Costela, 797 - Sion - 03517039 Silva Grande / SP') == 17\n",
    "assert conta_vogais('Clara Correia') == 6\n",
    "assert conta_vogais('Conjunto Rodrigues, 41 - Vila Pinho - 81177-479 Silva / SC') == 13\n",
    "assert conta_vogais('Emanuel Costela') == 7\n",
    "assert conta_vogais('Colônia Carolina Cardoso, 30 - Vila Canto Do Sabiá - 48402517 Castro / MT') == 19"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Complete a função que corrige um número de celular digitado.\n",
    "\n",
    "Se for do padrão antigo (8 caracteres) adicionar um 9 no começo.\n",
    "\n",
    "Se o celular enviado já possuir 9 deverá verificar se o primeiro caracter é 9. Se não for troque-o para 9.\n",
    "\n",
    "Se conter menos que 8 ou mais que 9 levante uma exceção."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def corrige_celular(celular):\n",
    "    if len(celular) == 8:\n",
    "        ...  # corrige e retorna o celular\n",
    "    elif len(celular) == 9:\n",
    "        ...  # verifica se o celular está correto e retorna número corrigido se necessario\n",
    "    else:\n",
    "        raise ValueError('Celular \"{0}\" é inválido'.format(celular))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "assert corrige_celular(\"733080280\") == \"933080280\"\n",
    "assert corrige_celular(\"820229289\") == \"920229289\"\n",
    "assert corrige_celular(\"634950619\") == \"934950619\"\n",
    "assert corrige_celular(\"620143587\") == \"920143587\"\n",
    "assert corrige_celular(\"27439428\") == \"927439428\"\n",
    "assert corrige_celular(\"11856634\") == \"911856634\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controle de fluxo\n",
    "\n",
    "#### if...elif...else\n",
    "Já foi mostrado em alguns exemplos anteriores o uso do `if`...`elif`...`else`, mas deixarei aqui alguns exemplos e explicações para não haver duvidas:\n",
    "\n",
    "A função `input` em um script para o mesmo e espera a entrada de um usuário. Já no Jupyter Notebook essa função cria um campo de entrada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "nota = float(input())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Passou com 10.0!\n"
     ]
    }
   ],
   "source": [
    "if nota < 0 or nota > 10:\n",
    "    raise ValueError('Nota {} inválida'.format(nota))  # levanta uma exceção do tipo ValueError\n",
    "elif nota < 5:\n",
    "    print('{}... reprovado'.format(nota))\n",
    "elif 5 <= nota <= 10:  # o python permite comparação encadeada\n",
    "    print('Passou com {}!'.format(nota))\n",
    "elif nota == 10:\n",
    "    print('Parabens pelo 10.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos colocar esse trecho de código em uma função para poder testá-la:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def resultado(nota):\n",
    "    if nota < 0 or nota > 10:\n",
    "        raise ValueError('Nota {} inválida'.format(nota))  # levanta uma exceção do tipo ValueError\n",
    "    elif nota < 5:\n",
    "        print('{}... reprovado'.format(nota))\n",
    "    elif 10 > nota >= 5:  # o python permite comparação encadeada\n",
    "        print('Passou com {}!'.format(nota))\n",
    "    elif nota == 10:\n",
    "        print('Parabens pelo 10.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.25... reprovado\n",
      "Passou com 6!\n",
      "Parabens pelo 10.\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Nota 150 inválida",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-105-79b96739d1b9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mnota\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m3.25\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m6\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m150\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[0mresultado\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnota\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-104-6f801b607e9a>\u001b[0m in \u001b[0;36mresultado\u001b[1;34m(nota)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mresultado\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnota\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mnota\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mnota\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Nota {} inválida'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnota\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# levanta uma exceção do tipo ValueError\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[1;32melif\u001b[0m \u001b[0mnota\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'{}... reprovado'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnota\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Nota 150 inválida"
     ]
    }
   ],
   "source": [
    "for nota in (3.25, 6, 10, 150):\n",
    "    resultado(nota)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### while\n",
    "\n",
    "O `while` permite repetir uma sequência de código até uma condição ser satisfeita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10...\n",
      "9...\n",
      "8...\n",
      "7...\n",
      "6...\n",
      "5...\n",
      "4...\n",
      "3...\n",
      "2...\n",
      "1...\n",
      "0!!!\n"
     ]
    }
   ],
   "source": [
    "from time import sleep\n",
    "\n",
    "n = 10\n",
    "while n > 0:\n",
    "    print('{}...'.format(n))\n",
    "    sleep(1)\n",
    "    n -= 1\n",
    "print('0!!!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nem sempre a condição precisa ser satisfeita (loop infinito):\n",
    "\n",
    "*Se você rodar um loop infinito no Jupyter Notebook vai travar o servidor e não poderá executar outras células de código*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "while True:\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calcular uma subsequência de Fibonacci até certo valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n"
     ]
    }
   ],
   "source": [
    "a, b = 0, 1  # atribuição múltipla\n",
    "while b < 100:\n",
    "    print(b)\n",
    "    a, b = b, a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O `print()` acabou imprimindo a sequência em linhas separadas, pois ao final de cada print é anexado um caracter de quebra de linha `\\n`. Para modificar esse comportamento podemos fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 3 5 8 13 21 34 55 89 "
     ]
    }
   ],
   "source": [
    "a, b = 0, 1\n",
    "while b < 100:\n",
    "    print(b, end=' ')\n",
    "    a, b = b, a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Podemos usar while para fazer um simples jogo de advinhar o número sorteado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Qual foi o número sorteado: 50\n",
      "tentativa > sorteado\n",
      "\n",
      "Qual foi o número sorteado: 25\n",
      "tentativa > sorteado\n",
      "\n",
      "Qual foi o número sorteado: 12\n",
      "tentativa < sorteado\n",
      "\n",
      "Qual foi o número sorteado: 19\n",
      "tentativa < sorteado\n",
      "\n",
      "Qual foi o número sorteado: 15\n",
      "tentativa < sorteado\n",
      "\n",
      "Qual foi o número sorteado: 22\n",
      "tentativa > sorteado\n",
      "\n",
      "Qual foi o número sorteado: 21\n",
      "tentativa > sorteado\n",
      "\n",
      "Qual foi o número sorteado: 20\n",
      "Você acertou!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "sorteado = random.randint(1, 101)  # sorteia um inteiro entre 1 e 100\n",
    "tentativa = 0\n",
    "\n",
    "while tentativa != sorteado:\n",
    "    tentativa = int(input('Qual foi o número sorteado: '))\n",
    "    \n",
    "    if tentativa > sorteado:\n",
    "        print('tentativa > sorteado\\n')\n",
    "    elif tentativa < sorteado:\n",
    "        print('tentativa < sorteado\\n')\n",
    "\n",
    "print('Você acertou!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Extra*\n",
    "\n",
    "Usando o algoritmo de busca binária é possível sempre encontrar o resultado com até ceil(log2(100)) == 7 tentativas. Para saber mais sobre esse algoritmo consulte nossa amiga [wikipédia](https://en.wikipedia.org/wiki/Binary_search_algorithm#Algorithm) (em inglês, pois a versão em portugês não explica o algoritmo direito)."
   ]
  }
 ],
 "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.5.1+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}