Aula05.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"homesweethome\"></div>\n",
    "\n",
    "<div style=\"width: 100%; text-align: center; color: white; background-color: #222; font-size: 3em; font-weight: 700; padding: .5em .5em .6em .5em; line-height: 1.4em;\">Programação em Python para Iniciantes</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "<div style=\"width: 100%; text-align: center; color: white; background-color: #555; font-size: 2.2em; font-weight: 700; padding: .5em .5em .6em .5em; line-height: 1em;\">Funções e Módulos</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "Nesta unidade, vamos primeiro fazer uma pequena revisão do que vimos até o momento. Depois vamos ensiná-lo a estruturar seu código usando funções e, finalmente, vamos ensiná-lo a usar módulos (bibliotecas de funções) prontos. \n",
    "\n",
    "<span style=\"color: red;\">Lembre-se: Execute a última célula para melhorar a aparência deste <i>notebook</i>.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Revisão\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nas últimas aulas você aprendeu alguns poucos comandos da linguagem Python, mas com esse pequeno conhecimento já é possível construir programas bastante complexos. \n",
    "\n",
    "Primeiramente, você aprendeu a fazer contas em Python, usando variáveis e expressões matemáticas. \n",
    "\n",
    "Depois, você viu como fazer para perguntar e mostrar dados ao usuário através das funções `input()` e `print()`.\n",
    "\n",
    "Você também aprendeu a tomar decisões de acordo com o resultado de testes booleanos usando o comando `if`. \n",
    "\n",
    "Finalmente, você teve contato com laços de repetição (comandos `for` e `while`) e com o uso de listas (_lists_), tuplas (_tuples_) e intervalos (_ranges_) para armazenar valores de dados.\n",
    "\n",
    "De todos esses tópicos, acreditamos que os laços de repetição e as listas (e suas variantes) são os que mais podem levantar dúvidas e apresentar obstáculos no aprendizado. Por isso, vamos revisá-los aqui através de exercícios resolvidos. \n",
    "\n",
    "Alguns exercícios serão idênticos aos pedidos na última aula (como exercícios para o recesso) e outros serão ligeiramente diferentes, assim se você não conseguiu fazer alguns daqueles exercícios, você pode tentar novamente, agora com a ajuda de uma solução para um problema parecido.\n",
    "\n",
    "**Atenção:** ao ler os exercícios resolvidos, você deve entender cada observação, cada linha de código, cada vírgula do programa! Se você tiver dificuldade em entender algum detalhe do programa-resposta, pergunte ao professor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício resolvido: números triangulares\n",
    "\n",
    "Um número natural $n$ é chamado de *triangular* se $n$ esferas idênticas podem ser dispostas em uma pilha de forma triângular. Veja na figura a seguir que os números 1, 3, 6 e 10 são números triangulares.\n",
    "\n",
    "<img src=\"http://tidia4.ufabc.edu.br/access/content/group/8398384e-4091-4504-9c21-eae9a6a24a61/Unidade%208/triangular.png\" width=\"400px\"></img>\n",
    "\n",
    "O número 1 também é considerado triangular, embora seja questionável se uma pilha com uma única esfera tenha forma triangular.\n",
    "\n",
    "---\n",
    "\n",
    "Para fazermos um programa que mostre qual é o $n$-ésimo número triangular, precisamos de um laço que faça uma variável, digamos `i`, percorrer os números de 1 até $n$. Podemos usar um `for`.\n",
    "\n",
    "A cada iteração `i` queremos contar quantas bolinhas tem a $i$-ésima pilha. A primeira pilha tem 1 bolinha; a segunda tem 3 = (2 na base + 1) bolinhas; a terceira tem 6 = (3 na base + 3); a quarta tem 10 = (4 na base + 6); etc. \n",
    "\n",
    "Mais em geral, a $i$-ésima pilha tem $i$ bolinhas na base e, sobre esta base, uma réplica da pilha $i - 1$. Podemos usar uma variável que conta quantas bolinhas havia na última pilha. Vamos chamá-la de `ultima_pilha`. Inicialmente, essa variável tem o valor $0$.\n",
    "\n",
    "O programa fica assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# preencha aqui a solução que o professor fizer em sala"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = int(input(\"Qual o valor de n? \"))\n",
    "ultima_pilha = 0\n",
    "\n",
    "for i in range(1, n + 1):\n",
    "    nova_pilha = i + ultima_pilha\n",
    "    ultima_pilha = nova_pilha\n",
    "    \n",
    "print(\"O \" + str(n) + \"º número triangular é \" + str(ultima_pilha) + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício resolvido: conversão para a base 3\n",
    "\n",
    "Faça um programa que pede ao usuário um número inteiro $n > 0$ e que depois mostre a representação em base 3 de $n$. Ou seja, faça um programa de conversão de base. Por exemplo, a representação em base 3 de 17 é 122, pois $17 = 1 \\cdot 9 + 2 \\cdot 3 + 2\\cdot 1$.\n",
    "\n",
    "A solução é parecida com a solução do problema _Troco_: suponha que você quer trocar o valor $n$ em moedas de valores que são potências de 3 assim: $1, 3, 9, 27, 81, \\dots$.\n",
    "\n",
    "O modo mais natural de se fazer esse exercício &ndash; se é que vamos nos basear no problema do troco &ndash; é ver qual a maior potência de 3 que é menor ou igual a $n$, digamos que é $3^k$. Subtrair $3^k$ de $n$ repetidas vezes até que o que sobre seja menor que $3^k$. O número $q$ de vezes que subtraímos $3^k$ de $n$ até o resto ficar menor que $3^k$ é o $k$-ésimo dígito de $n$ em base 3. Atualizamos o valor de $n$ para conter o resto e repetimos o procedimento com $k - 1$ para encontrar o dígito seguinte. Depois repetimos para $k - 2$ e assim por diante até $k$ se tornar menor que 0, quando devemos parar. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = int(input(\"Qual o valor de n que será convertido para base 3? \"))\n",
    "print(n, \"em base 3 é \", end=\"\")       # end=\"\" diz para o print não pular linha no final\n",
    "\n",
    "# descobre a maior potência de 3 menor ou igual que n\n",
    "k = 0\n",
    "while 3**k <= n:\n",
    "    k = k + 1\n",
    "k = k - 1\n",
    "\n",
    "# variável que guardará a representação textual de n em base 3\n",
    "b = \"\"\n",
    "\n",
    "while k >= 0:\n",
    "    q = n // 3**k        # quantas vezes 3**k cabe dentro de n\n",
    "    n = n % 3**k         # resto       \n",
    "    b = b + str(q)       # concatena dígito q com os dígitos já obtidos\n",
    "    k = k - 1     \n",
    "    \n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Há ainda um outro jeito de se fazer mudança de base que usa os operadores `%` e `//`, mas descobrindo os dígitos menos significativos primeiro. O código é um pouco mais sucinto, embora seja, talvez, menos natural para alguns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# preencha aqui a solução que o professor fizer em sala"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = int(input(\"Qual o valor de n que será convertido para base 3? \"))\n",
    "print(n, \"em base 3 é \", end=\"\")\n",
    "\n",
    "b = \"\"\n",
    "while n > 0:\n",
    "    b = str(n % 3) + b\n",
    "    n = n // 3\n",
    "    \n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício resolvido: palíndromos\n",
    "\n",
    "Escreva um programa eficiente para verificar se uma palavra é um palíndromo, i.e. poder ser lida da mesma forma tanto da direita para a esquerda como da\n",
    "esquerda para a direita. Exemplo: \"reviver\", \"mirim\", \"matam\", \"ovo\", \"osso\", \"rodador\".\n",
    "\n",
    "---\n",
    "\n",
    "Na terceira aula, vimos que um texto (_string_) pode ser entendido como uma tupla de caracteres, e que portanto podemos acessar cada caracter de um texto separadamente através de seu índice.\n",
    "\n",
    "Basta então comparar o primeiro caractere com o último, o segundo com o penúltimo, o terceiro com o antepenúltimo e assim por diante. Se alguma dessas comparações retornar que são caracteres diferentes, a palavra não é palíndroma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# preencha aqui a solução que o professor fizer em sala"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "texto = input('Escreva uma palavra: ')\n",
    "n = len(texto)\n",
    "for i in range(n // 2):\n",
    "    if texto[i] != texto[n - 1 - i]:\n",
    "        print(texto + ' não é palíndromo')\n",
    "        break\n",
    "else:\n",
    "    print(texto + ' é palíndromo')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício resolvido: notas acima da média\n",
    "\n",
    "Escreva um programa que, dadas as notas (entre zero e dez) de uma turma, imprima a média das notas e determine quantos estudantes tiraram nota acima da média. A leitura termina com qualquer nota não válida.\n",
    "\n",
    "Por exemplo, seja a entrada 10, 8.4, 9, 4.5, 3, 0, 6, -1. A média é 5.8 e há 4 notas acima dela."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# preencha aqui a solução que o professor fizer em sala"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# lê números e coloca-os numa lista até que uma nota não válida é lida\n",
    "lista_notas = []\n",
    "total = 0;\n",
    "\n",
    "while True:\n",
    "    n = float(input('Entre com uma nota: '))\n",
    "    if n < 0 or n > 10:\n",
    "        break\n",
    "    lista_notas.append(n)\n",
    "    total += n\n",
    "\n",
    "media = total / len(lista_notas)\n",
    "print('Média: %.2f' % media)\n",
    "    \n",
    "acima_da_media = 0\n",
    "for n in lista_notas:\n",
    "    if n > media:\n",
    "        acima_da_media += 1\n",
    "        \n",
    "print('Número de estudantes com nota acima da média:', acima_da_media)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício resolvido: todos os primos\n",
    "\n",
    "Escreva um programa que, dado um número inteiro M, imprime todos os números primos menores ou iguais a M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M = int(input('Entre com o valor de M: '))\n",
    "\n",
    "for n in range(2, M + 1):\n",
    "    # testa se n é primo\n",
    "    for i in range(2, n):\n",
    "        if n % i == 0: # or i*i > n:\n",
    "            break\n",
    "    else:\n",
    "        # Se chegamos até aqui é porque n não é múltiplo\n",
    "        # de nenhum número estritamente entre 1 e n.\n",
    "        print(n, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funções\n",
    "\n",
    "Nesta seção, você vai aprender a organizar melhor o seu código através do uso de funções."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplo 1\n",
    "\n",
    "Vamos introduzir funções por meio de um exemplo. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def media(a, b):\n",
    "    return (a + b) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na célula anterior, definimos uma função `media()`, que recebe dois parâmetros e que devolve a média aritmética deles.\n",
    "\n",
    "Uma vez definida a função `media()`, podemos usá-la muitas vezes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "media(4, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "media(7, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "media(5.3, 8.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tradicionalmente, nos referimos ao uso de uma função dizendo que houve uma **chamada** da função. Por exemplo, com relação à célula de código acima, podemos dizer:\n",
    "\n",
    "\n",
    "<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&ldquo;<i>A função <code>media()</code> foi chamada com os parâmetros 5.3 e 8.9.</i>&rdquo;</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python, a sintaxe para definirmos uma função é a seguinte:\n",
    "\n",
    "    def nome_da_função(parâmetros separados por vírgula):\n",
    "        .\n",
    "        .\n",
    "        .\n",
    "        bloco de código da função\n",
    "        .\n",
    "        .\n",
    "        .\n",
    "        \n",
    "O bloco de código indentado da função também é chamado de _**corpo** da função_.\n",
    "\n",
    "### Valor de retorno\n",
    "\n",
    "Quando, durante a execução de uma função, o comando `return` é encontrado a função termina de executar imediatamente, mesmo se ainda houver código dentro corpo da função. Geralmente o comando `return` é seguido de algum valor. Nesse caso, esse valor é devolvido como sendo o resultado da execução da função.\n",
    "\n",
    "Se a execução da função chegar até o fim do corpo da função sem encontrar `return` (ou se `return` não for seguido de nenhum valor), o valor especial `None` é devolvido.\n",
    "\n",
    "Em vista disso pode-se dizer da linha `media(7, 9)` que:\n",
    "\n",
    "<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&ldquo;<i>A função <code>media()</code> foi chamada com os parâmetros 7 e 9 e devolveu o valor 8.0.</i>&rdquo;</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exemplo 2\n",
    "\n",
    "Consideremos agora o exercício de se verificar se uma palavra é palíndroma. \n",
    "\n",
    "Abaixo, colocamos uma réplica da solução feita em sala."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "texto = input('Escreva uma palavra: ')\n",
    "n = len(texto)\n",
    "\n",
    "for i in range(n // 2):\n",
    "    if texto[i] != texto[n - 1 - i]:\n",
    "        print(texto + ' não é palíndromo')\n",
    "        break\n",
    "else:\n",
    "    print(texto + ' é palíndromo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Podemos extrair desse código uma função que retorna `True` ou `False` dependendo do texto passado como parâmetro ser palíndromo ou não. \n",
    "\n",
    "Veja como fica:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def eh_palindromo(texto):\n",
    "    n = len(texto)\n",
    "\n",
    "    for i in range(n // 2):\n",
    "        if texto[i] != texto[n - 1 - i]:\n",
    "            return False\n",
    "    \n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em seguida, podemos chamar essa função várias vezes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "eh_palindromo('mirim')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "eh_palindromo('socorrammesubinoonibusemmarrocos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "eh_palindromo('abracadabra')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplo 3\n",
    "\n",
    "Vamos aogra explorar o último exercício resolvido da seção de revisão que pedia para listarmos todos os primos até um certo limite $M$.\n",
    "\n",
    "Vamos replicar o código-resposta na célula abaixo. Clique na célula e tecle <kbd>ESC</kbd> depois <kbd>L</kbd> para exibir a numeração das linhas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M = int(input('Entre com o valor de M: '))\n",
    "\n",
    "for n in range(2, M + 1):\n",
    "    # testa se n é primo\n",
    "    for i in range(2, n):\n",
    "        if n % i == 0: \n",
    "            break\n",
    "    else:\n",
    "        # Se chegamos até aqui é porque n não é múltiplo\n",
    "        # de nenhum número estritamente entre 1 e n.\n",
    "        print(n, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Repare que, no programa-resposta, o bloco de código do laço mais externo (linhas 4 a 11) é a parte do código que é responsável por verificar a primalidade de $n$.\n",
    "\n",
    "Podemos aumentar a legibilidade do programa extraindo esse bloco e colocando-o dentro de uma função. Veja o exemplo abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def eh_primo(n):\n",
    "    if n < 2: return False\n",
    "    for i in range(2, n):\n",
    "        if n % i == 0: \n",
    "            return False\n",
    "    return True\n",
    "\n",
    "M = int(input('Entre com o valor de M: '))\n",
    "\n",
    "for n in range(2, M + 1):\n",
    "    if eh_primo(n):\n",
    "        print(n, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função `eh_primo()` implementa o teste de primalidade. Ela possui um único argumento `n` e, dependendo do valor de `n`, a função retorna `True` ou `False`.\n",
    "\n",
    "Não ficou mais legível este código?\n",
    "\n",
    "Uma vez que definimos uma função, podemos usá-la quantas vezes quisermos. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "eh_primo(125)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "eh_primo(141073)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "eh_primo(17777)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: distância entre pontos\n",
    "\n",
    "Faça uma função `dist()` que recebe 4 parâmetros $x_1, y_1, x_2$ e $y_2$ e que devolve a distância entre os pontos $(x_1, y_1)$ e $(x_2, y_2)$. Lembre-se de que a fórmula para a distância entre dois pontos é\n",
    "\n",
    "$$ d = \\sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2}. $$\n",
    "\n",
    "Depois use sua função para calcular a distância entre os pares de pontos\n",
    "\n",
    "* $(2,7)$ e $(14, 2)$ (a resposta deve dar $13$)\n",
    "* $(1,3)$ e $(5,6)$\n",
    "* $(2,5)$ e $(3,-10)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: lista ordenada\n",
    "\n",
    "Faça uma função `esta_ordenada()` que recebe um único parâmetro que é uma lista e que devolve `True` se a lista está em ordem crescente e `False` caso contrário.\n",
    "\n",
    "Depois chame sua função para as listas\n",
    "\n",
    "* `[2, 5, 7, 12, 34, 46, 69, 123, 192]`, e\n",
    "* `[1, 2, 1, 2, 1, 2]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passagem por valor ou por referência?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma pergunta que você pode ter é se uma mudança feita no valor de um parâmetro de uma função durante a execução dessa função pode surtir algum efeito fora dela.\n",
    "\n",
    "Veja o código abaixo, tente prever a saída e depois execute a célula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def funcao(valor):\n",
    "    if valor > 10:\n",
    "        valor = 10\n",
    "    \n",
    "a = 13\n",
    "funcao(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A saída é 13 e não 10, pois quando a chamada `funcao(a)` é feita, é o valor de `a` que é passado como parâmetro para a função. Ou seja, é como se `funcao(13)` estivesse sendo chamada.\n",
    "\n",
    "Por outro lado, existem casos em que a função pode, sim, ter um efeito colateral. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "def func(L):\n",
    "    L.append('AH!')\n",
    "    \n",
    "func(lista)\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então como fazer para distinguir um caso do outro? \n",
    "\n",
    "A regra é a seguinte. Quando um tipo imutável é passado como parâmetro &ndash; _int_, _float_, _tuple_, _range_, _string_ &ndash; a passagem é feita por valor (e, portanto, alterações feitas na variável do parâmetro não tem efeitos fora da função); e quando o tipo é mutável &ndash; _list_ ou alguma classe (Programação Orientada a Objetos) &ndash; a passagem é feita por referência (alterações têm efeito colateral fora da função).\n",
    "\n",
    "Para uma discussão mais precisa sobre o assunto veja [Is Python call-by-value or call-by-reference? Neither.](https://jeffknupp.com/blog/2012/11/13/is-python-callbyvalue-or-callbyreference-neither/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escopo de variáveis\n",
    "\n",
    "Nesta seção, vamos chamar a atenção sobre o fato de que uma variável definida em algum lugar do programa pode não estar definida em outros trechos do código.\n",
    "\n",
    "Veja o (mau) exemplo abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def eh_positivo(num):\n",
    "    if num > 0:\n",
    "        print(positivo)\n",
    "    else:\n",
    "        print(negativo)\n",
    "        \n",
    "print(num)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que, ao executar o código acima, o programa termina abruptamente por causa de um erro de execução:\n",
    "\n",
    "    NameError: name 'num' is not defined\n",
    "    \n",
    "Isso acontece pois `num` é um parâmetro da função `eh_positivo()` e só faz sentido dentro do corpo da função. Fora dela, o nome `num` não estava definido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E se acessarmos uma variável global de dentro do corpo de uma função? Isso é possível?\n",
    "\n",
    "Sim, mas precisamos tomar cuidado. Veja o exemplo abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 0\n",
    "\n",
    "def minha_funcao():\n",
    "    print(a)\n",
    "\n",
    "minha_funcao()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como esperado, ao chamarmos a função `minha_funcao()`, o valor `0` foi impresso. \n",
    "\n",
    "Agora, veja o que acontece no programa a seguir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 0\n",
    "\n",
    "def minha_funcao():\n",
    "    a = 3\n",
    "    print(a)\n",
    "\n",
    "minha_funcao()\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando a função `minha_funcao()` é chamada, o `print` dentro da funçao imprime `3`, mas por que o `print` no fim do programa imprime `0`?\n",
    "\n",
    "O comportamento padrão do Python é criar uma variável local sempre que uma atribuição é feita. Por isso quando a linha `a = 3` é executada, uma variável local `a` é criada e seu valor é definido como sendo `3`. Em termos corriqueiros, pode-se dizer que a vida útil dessa variável está confinada ao corpo da função. Quando a linha `print(a)` é executada a variável impressa é a variável local, pois quando existe uma variável local com o mesmo nome que uma variável global, a variável local tem precedência. A última linha imprime o valor da variável global, que permaneceu inalterado.\n",
    "\n",
    "Mas, então, como alterar o valor de uma variável global de dentro de uma função?\n",
    "\n",
    "Você pode fazer isso declarando, no corpo da função, que uma variável é global com a palavra-chave `global`. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 0\n",
    "\n",
    "def my_function():\n",
    "    global a\n",
    "    a = 3\n",
    "    print(a)\n",
    "\n",
    "my_function()\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: lista inversa I\n",
    "\n",
    "Faça uma função `inverteI()` que recebe um único parâmetro que contem uma lista do Python (_list_) e que inverte os elementos dessa lista de lugar (depois de chamar a função, os elementos dessa lista estarão na ordem inversa). Sua função não deve retornar nenhum valor (não usar `return`).\n",
    "\n",
    "**Atenção:** lembre-se de que, quando o parâmetro de uma função é uma lista, apenas uma referência para a lista é passada para a função (e não uma cópia dos dados). Assim, qualquer alteração feita pela função na lista passada como parâmetro irá permanecer após o término daquela chamada da função.\n",
    "\n",
    "**Dica:** como no exercício dos palíndromos, considere os elementos dessa lista aos pares. Ou seja, troque o primeiro com o último, o segundo com o penúltimo, e assim por diante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: lista inversa II\n",
    "\n",
    "Faça uma função `inverteII()` que recebe uma lista e que devolve uma outra lista com os elementos na ordem inversa. Após o término da chamada da função, a lista passada como parâmetro deve permanecer como estava entas da função ser chamada. Você deve usar `return`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: palíndromos II\n",
    "\n",
    "Escreva um programa para verificar se uma frase é um palíndromo. Exemplos: \"missa e assim\", \"roma me tem amor\", \"nos ligou\n",
    "o gilson\", \"luz azul\", \"ame o poema\", \"a sacada da casa\", \"a torre da derrota\", \"socorram me subi no onibus em marrocos\". Note-se que nas frases, os espaços não são considerados.\n",
    "\n",
    "Este era um exercício que propusemos para o recesso. Se você conseguiu fazer, ótimo!\n",
    "\n",
    "Agora sua tarefa vai ser fazer o exercício usando funções. Você deverá implementar \n",
    "uma função `tira_espacos()` que deve receber um texto como parâmetro e devolver outro texto, só que sem os espaços, ou seja, grudando todas as palavras da frase no texto. Depois você deve criar uma segunda função `eh_frase_palindroma()` que recebe um texto contendo uma frase e que usa a função anterior e outra função feita nesta aula (`eh_palindromo()` ou `inverteI()` ou `inverteII()`) para retornar `True` se a frase é palíndroma ou `False` caso contrário, e assim resolver o exercício.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recursão\n",
    "\n",
    "Dizemos que uma função é recursiva se, dentro do corpo dessa função existe uma chamada para a própria função. <img src=\"data:image/jpeg;base64,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\n",
    "\" />\n",
    "\n",
    "Quando fazemos uma função recursiva, devemos ter muito cuidado para que a função não \"entre em loop\". Para evitar loops eternos, devemos prestar atenção às condições de parada (casos em que não fazemos chamada recursiva). Vejamos um exemplo.\n",
    "\n",
    "## Exemplo\n",
    "\n",
    "Lembre-se de que \n",
    "\n",
    "$$ n! = n \\times (n - 1) \\times \\cdots \\times 3 \\times 2 \\times 1. $$\n",
    "\n",
    "Repare que, se $n > 1$, podemos escrever:\n",
    "\n",
    "$$ n! = n \\times (n - 1)!$$\n",
    "\n",
    "Isso nos indica uma maneira de escrever uma função que calcula o fatorial de $n$. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fatorial(n):\n",
    "    if n == 1:\n",
    "        return 1\n",
    "    # se não retornou até agora é porque n > 1\n",
    "    return fatorial(n - 1) * n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na verdade, $0!$ é definido como 1 e vamos supor que $n!$ não está definido para inteiros negativos, então uma versão melhorada seria:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fatorial(n):\n",
    "    if n < 0:\n",
    "        print('Não está definido.')\n",
    "        return\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    return fatorial(n - 1) * n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos testar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fatorial(5) == 5*4*3*2*1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fatorial(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que acontece se chamarmos a função para um número que não é inteiro?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fatorial(5.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você consegue explicar o que aconteceu nessa última chamada?\n",
    "\n",
    "Como dar uma mensagem de erro civilizada se o parâmetro não for _int_?\n",
    "\n",
    "Podemos usar a função `isinstance()` do Python. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fatorial(n):\n",
    "    if not isinstance(n, int) or n < 0:\n",
    "        print('A função fatorial não está definida para esse valor.')\n",
    "        return\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    return fatorial(n - 1) * n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fatorial(5.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outro exemplo\n",
    "\n",
    "Faça um programa que pede para o usuário digitar um número $n>0$ e imprime um triângulo de asteriscos como na figura abaixo para $n=5$.\n",
    "\n",
    "<pre style=\"background-color: rgba(0,0,0,0);\">\n",
    "*\n",
    "**\n",
    "***\n",
    "****\n",
    "*****\n",
    "</pre>\n",
    "\n",
    "Este era outro exercício para o recesso. Podemos resolvê-lo através de uma função recursiva:\n",
    "\n",
    "<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&ldquo;<i>Um triângulo-astersco para $n$ é um triângulo-asterisco para $n - 1$ seguido de uma nova linha com $n$ asteriscos.</i>&rdquo;</p>\n",
    "\n",
    "Com essa observação e com a observação de que um triângulo-astersco para $n = 1$ é apenas um asterisco (condição de parada), podemos escrever uma função recursiva para fazer isso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def triangulo(n):\n",
    "    # verifica o domínio da função\n",
    "    if not isinstance(n, int) or n < 0:\n",
    "        print('Não sei fazer isso!')\n",
    "        return\n",
    "    # condição de parada\n",
    "    if n == 1:\n",
    "        print('*')\n",
    "    elif n > 1:\n",
    "        # caso recursivo\n",
    "        triangulo(n - 1)\n",
    "        print('*' * n)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "triangulo(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "triangulo(-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "triangulo(5.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: soma de 1 a n\n",
    "\n",
    "Faça uma função `soma_1_ate()` que recebe um parâmetro `n` e que calcula a soma\n",
    "\n",
    "$$ 1 + 2 + \\cdots + n. $$\n",
    "\n",
    "Não se esqueça de colocar uma condição de parada! \n",
    "\n",
    "Por enquanto, não se preocupe em testar se o parâmetro dado é inteiro ou maior que 0.\n",
    "\n",
    "**Dica:** parecido com a função fatorial..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na célula abaixo, teste sua função passando 100 como parâmetro. A resposta deve ser 5050."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que sua função funciona com parâmetros inteiros, acrescente verificações do domínio da função. ão de tipo do parêmtro. Se o parâmetro não for inteiro ou se for menor que 1, imprima uma mensagem ao usuário dizendo que sua função não está definida para aqueles valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Teste a nova versão da sua função:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "soma_1_ate(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "soma_1_ate(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "soma_1_ate(3.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Módulos\n",
    "\n",
    "Módulos nada mais são do que programas feitos em Python que estão prontos para serem usados. Geralmente são coleções de funções em Python que proveem soluções para problemas conhecidos e que podemos usar sem ter que conhecer os detalhes de sua implementação interna. Basta que saibamos quais os nomes e os argumentos de cada função.\n",
    "\n",
    "Vamos começar com o módulo `math` que disponibiliza algumas funções matemáticas como seno, cosseno, tangente, etc., e também algumas constantes como $\\pi$.\n",
    "\n",
    "Para usar um módulo precisamos importá-lo.\n",
    "\n",
    "Veja o exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print('O valor de pi é', math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma vez importado o módulo, podemos usá-lo nas células seguintes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('O seno de pi/2 é', math.sin(pi/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esteja ciente de que, se você reiniciar o kernel do Python (no Jupyter), você terá que importar o módulo que estiver usando novamente antes de executar células que dependem dele.\n",
    "\n",
    "Para ver uma relação das funções e constantes definidas no módulo importado você pode usar a função `help()` do Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que, para se chamar qualquer função do módulo importado é necessário digitar o nome do módulo seguido de um ponto `.` seguido do nome da função. A mesma coisa vale para as constantes definidas naquele módulo.\n",
    "\n",
    "Se você irá usar uma função (ou constante) muitas vezes e se cansa de escrever o nome do módulo toda vez, você pode importar essas funções diretamente para o espaço de nomes padrão com o seguinte comando."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from math import pi, sin\n",
    "\n",
    "print('O valor de pi é', pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('O seno de pi/2 é', sin(pi/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na célula em que temos o comando `from ... import ...`, somente mandamos importar os nomes `pi` e `sin` do módulo `math`. Se tentarmos, por exemplo, usar a função cosseno (`cos`) teremos problemas, pois esse nome não foi importado. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cos(pi/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É uma boa prática importarmos somente os nomes (de funções ou constantes) que precisamos usar. Mas, se você vai usar muitas funções do módulo e vai usá-las muitas vezes, também é possível importar tudo através da linha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplo: lendo arquivos da web"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "\n",
    "data = urlopen(\"https://www.eyrie.org/~brainy9/poetry/angst.txt\")  \n",
    "for line in data: \n",
    "    print(line.decode(\"utf-8\"), end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplo: listando arquivos de um diretório do sistema"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "os.listdir('.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemplo: manipulação de imagens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import time as t\n",
    "print(\"OpenCV Version : %s \" % cv2.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se a execução da célula acima gerar um erro, será preciso instalar o módulo OpenCV para Python. Se não der erro, você deverá ver a versão da biblioteca OpenCV instalada na sua máquina.\n",
    "\n",
    "Para instalar o OpenCV, abra um terminal e digite as linhas de comando:\n",
    "\n",
    "    sudo -H pip3 install --upgrade pip\n",
    "    sudo -H pip3 install opencv-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "\n",
    "urllib.request.urlretrieve(\"http://ufabc.space/CursoPython/misc/haarcascade_frontalface_default.xml\", \"haarcascade_frontalface_default.xml\")\n",
    "faceCascade = cv2.CascadeClassifier(\"./haarcascade_frontalface_default.xml\")\n",
    "\n",
    "urllib.request.urlretrieve(\"http://ufabc.space/CursoPython/misc/cardinals.jpg\", \"cardinals.jpg\")\n",
    "image = cv2.imread(\"./cardinals.jpg\")\n",
    "\n",
    "cv_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "\n",
    "plt.imshow(cv_rgb)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora rode o código abaixo para detectar rostos na imagem acima."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "faces = faceCascade.detectMultiScale(gray, scaleFactor=1.1, \n",
    "                                     minNeighbors=5, minSize=(30, 30), \n",
    "                                     flags = cv2.CASCADE_SCALE_IMAGE)\n",
    "\n",
    "print(\"Encontrou {0} rostos!\".format(len(faces)))\n",
    "\n",
    "for (x, y, w, h) in faces:\n",
    "    cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)\n",
    "    \n",
    "cv_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "\n",
    "plt.imshow(cv_rgb)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red;\">Execute a célula abaixo para melhorar a aparência deste <i>notebook</i>.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "init_cell": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".rendered_html h1 {\n",
       "    background-color: #555;\n",
       "    color: white;\n",
       "    padding: .5em;\n",
       "    // border-bottom: 2px solid #000;\n",
       "    // padding-bottom: .6em;\n",
       "    margin-bottom: 1em;\n",
       "}\n",
       "\n",
       ".rendered_html h1 code {\n",
       "    color: #EBB7C5;\n",
       "    background-color: rgba(0,0,0,0);\n",
       "}\n",
       "\n",
       ".rendered_html h2 {\n",
       "    border-bottom: 1px solid #333;\n",
       "    padding-bottom: .6em;\n",
       "}\n",
       "                                      \n",
       ".rendered_html h3 {\n",
       "    color: #034f84;\n",
       "}\n",
       "\n",
       ".rendered_html code  {\n",
       "    padding: 2px 4px;\n",
       "    font-size: 90%;\n",
       "    color: #c7254e;\n",
       "    background-color: #f9f2f4;\n",
       "    border-radius: 4px;\n",
       "}\n",
       "\n",
       ".rendered_html pre code {\n",
       "    padding: 0px;\n",
       "    font-size: 90%;\n",
       "    color: #c7254e;\n",
       "    background-color: rgba(0, 0, 0, 0);\n",
       "}\n",
       "\n",
       "kbd {\n",
       "    border-radius: 3px;  \n",
       "    padding: 2px, 3px;\n",
       "}\n",
       "\n",
       "body {\n",
       "    counter-reset: h1counter excounter;\n",
       "}\n",
       "h1:before {\n",
       "    content: counter(h1counter) \".\\0000a0\\0000a0\";\n",
       "    counter-increment: h1counter;\n",
       "}\n",
       "span.exec:before {\n",
       "    content: counter(excounter);\n",
       "    counter-increment: excounter;\n",
       "}\n",
       "\n",
       "</style>  \n",
       "<script>\n",
       "location.hash = \"#homesweethome\";\n",
       "</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    ".rendered_html h1 {\n",
    "    background-color: #555;\n",
    "    color: white;\n",
    "    padding: .5em;\n",
    "    // border-bottom: 2px solid #000;\n",
    "    // padding-bottom: .6em;\n",
    "    margin-bottom: 1em;\n",
    "}\n",
    "\n",
    ".rendered_html h1 code {\n",
    "    color: #EBB7C5;\n",
    "    background-color: rgba(0,0,0,0);\n",
    "}\n",
    "\n",
    ".rendered_html h2 {\n",
    "    border-bottom: 1px solid #333;\n",
    "    padding-bottom: .6em;\n",
    "}\n",
    "                                      \n",
    ".rendered_html h3 {\n",
    "    color: #034f84;\n",
    "}\n",
    "\n",
    ".rendered_html code  {\n",
    "    padding: 2px 4px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: #f9f2f4;\n",
    "    border-radius: 4px;\n",
    "}\n",
    "\n",
    ".rendered_html pre code {\n",
    "    padding: 0px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: rgba(0, 0, 0, 0);\n",
    "}\n",
    "\n",
    "kbd {\n",
    "    border-radius: 3px;  \n",
    "    padding: 2px, 3px;\n",
    "}\n",
    "\n",
    "body {\n",
    "    counter-reset: h1counter excounter;\n",
    "}\n",
    "h1:before {\n",
    "    content: counter(h1counter) \".\\0000a0\\0000a0\";\n",
    "    counter-increment: h1counter;\n",
    "}\n",
    "span.exec:before {\n",
    "    content: counter(excounter);\n",
    "    counter-increment: excounter;\n",
    "}\n",
    "\n",
    "</style>  \n",
    "<script>\n",
    "location.hash = \"#homesweethome\";\n",
    "</script>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}