Aula06Graficos.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;\">Gráficos</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "Nesta unidade, vamos introduzir o pacote **Matplotlib** do Python (http://matplotlib.org/) que permite fazer uma grande variedade de gráficos (ver por exemplo, https://plot.ly/matplotlib/). \n",
    "\n",
    "\n",
    "<span style=\"color: red;\">Lembre-se: Execute a última célula para melhorar a aparência deste <i>notebook</i>.</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "Vamos começar com um exemplo: suponha que você queira fazer um gráfico de linha para visualizar as cotações do dólar em algum periodo de um mês. \n",
    "\n",
    "A tabela abaixo mostra as cotações no periodo entre 1/9/2017 e 8/9/2017 segundo o Banco Central do Brasil (Fonte: http://www4.bcb.gov.br/pec/taxas/port/ptaxnpesq.asp?id=txcotacao).\n",
    "\n",
    "\n",
    "|  Data     | Compra  | Venda  |\n",
    "|:---------:|---------|--------|\n",
    "| 1/09/2017\t| 3.1327  | 3.1333 |\n",
    "| 4/09/2017\t| 3.1383  | 3.1389 |\n",
    "| 5/09/2017\t| 3.1197  | 3.1203 |\n",
    "| 6/09/2017\t| 3.1127  | 3.1133 |\n",
    "| 8/09/2017\t| 3.0902  | 3.0908 |\n",
    "\n",
    "Como fazer um gráfico com esses dados em Python?\n",
    "\n",
    "<hr>\n",
    "\n",
    "Começamos importando o módulo **`matplotlib.pyplot`** que tem diversas funções prontas para a gente usar. \n",
    "\n",
    "No código abaixo, estamos dando o \"apelido\" de <samp>plt</samp> para essa biblioteca. Assim, não temos que digitar **`matplotlib.pyplot`** toda vez que usarmos suas funções. \n",
    "\n",
    "A primeira linha de código **`%matplotlib notebook`** permite definir opções apropriadas para exibir os gráficos num notebook.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A forma mais simples de fazer o gráfico duma função $f: D\\to I$ em Python é usar diretamente a função predefinida **`plot`** do pacote **`matplotlib.pyplot`**. A chamada a **`plot`** deve ter como parâmetros duas listas com os valores do dominio $D$ e a imagem $I$ de $f$. \n",
    "\n",
    "Por exemplo, para fazer o gráfico com os dados do valor de compra do dólar segundo a tabela acima podemos usar a seguinte instrução. Execute seguinte a célula e veja o resultado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "diaMes = [1,4,5,6,8]                                   # Dominio\n",
    "valorCompra = [3.1327,3.1383,3.1197,3.1127,3.0902]     # Imagem\n",
    "plt.plot(diaMes, valorCompra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como você pode ver na última linha usamos o \"apelido\"  **`plt`** do pacote  antes de chamar a função **`plot()`**. \n",
    "\n",
    "Os valores da lista fornecida como primeiro parâmetro foram colocados no eixo X enquanto os do segundo parâmetro no eixo Y. \n",
    "\n",
    "Agora precisamos personalizar nosso gráfico e mostrar que o eixo X representa dias do mês e o eixo Y o valor da cotação do dólar. \n",
    "\n",
    "Então vamos colocar \"Dias de setembro\" no eixo X:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.xlabel(\"Dias de setembro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que o seu gráfico (acima) foi atualizado no eixo X. Vamos colocar \"Cotação do dólar\" como nome para o eixo Y:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.ylabel(\"Cotação do dólar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos colocar um título no gráfico?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.title(\"Valor de Compra do Dólar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Às vezes, é útil ter uma grade no gráfico. Isso é bem fácil de se fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora ficou melhor, não é verdade?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Opções da função **`plot`**\n",
    "\n",
    "A função **`plot`** tem várias opções para definir e personalizar o gráfico duma função. Por exemplo, é possível fornecer somente os valores do eixo Y. Nesse caso o eixo X toma automaticamente valores entre $0\\ldots N-1$, onde $N$ é o número de valores da imagem da função.\n",
    "\n",
    "Execute a seguinte célula e veja no gráfico acima o resultado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.plot([1.4, 3.1, 2.3, 3.25, 4, 2.7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que o domínio da nova função é [0,1,2,3,4,5] e o gráfico foi colocado junto com o anterior. Mas, e se você quisesse apagar o antigo e começar um novo? Basta clicar no símbolo de energia no topo do gráfico.\n",
    "\n",
    "![Desligar o gráfico](http://professor.ufabc.edu.br/~mirtha.lina/images/shutdown_graph.png)\n",
    "\n",
    "Vamos fazer um **novo** gráfico, agora usando a cor vermelha e pequenos círculos. A função **`plot`** permite definir as cores e marcas usadas para desenhar as funções. Para isso, é usado como parámetro uma cadeia de caracteres após os valores da imagem. \n",
    "\n",
    "Execute a célula abaixo e veja a diferença.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.plot([1.4, 3.1, 2.3, 3.25, 4, 2.7], 'ro')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguinte tabela mostrar alguns dos caracteres que são aceitos para controlar o estilo ou marcador de linha:\n",
    "\n",
    "\n",
    "|caracter  |\tsignificado       |\n",
    "|:--------:|----------------------|\n",
    "|'-'       | linha sólida         |\n",
    "|':'       | linha pontilhada     |\n",
    "|'.'       | marcador de ponto    |\n",
    "|'o'       | marcador de círculo  |\n",
    "|'s'       | marcador de quadrado |\n",
    "|'*'       | marcador de estrela  |\n",
    "|'+'       | marcador de +        |\n",
    "|'x'       | marcador de x        |\n",
    "|'D'       | marcador de diamante |\n",
    "\n",
    "\n",
    "As seguintes abreviaturas são suportadas para as cores:\n",
    "\n",
    "|caracter  |\tcor     |\n",
    "|:--------:|------------|\n",
    "|'b'       | azul       |\n",
    "|'g'       | verde      |\n",
    "|'r'       | vermelho   |\n",
    "|'c'       | cyan       |\n",
    "|'m'       | magenta    |\n",
    "|'y'       | amarelo    |\n",
    "|'k'       | preto      |\n",
    "|'w'       | branco     |\n",
    "\n",
    "\n",
    "\n",
    "Também, é possível colocar legendas e controlar a largura da linha. Você pode ver todas as opcões em http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot.\n",
    "\n",
    "A seguir alguns exemplos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.plot([1,2,3], [1,2,3], 'go-', label='Linha 1', linewidth=4)\n",
    "plt.plot([1,2,3], [1,4,9], 'rs:',  label='Linha 2')\n",
    "plt.plot([7,3.4,5.9], 'bD')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "Agora, vamos a escrever o programa Python completo para mostrar de forma gráfica os dados da tabela com a cotação do dólar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "diaMes = [1, 4, 5, 6, 8]\n",
    "valorCompra = [3.1327, 3.1383 ,3.1197, 3.1127, 3.0902]\n",
    "valorVenda = [ 3.1333, 3.1389, 3.1203, 3.1133, 3.0908 ]\n",
    "plt.plot(diaMes, valorCompra, 'bo-', label='Valor de Compra')\n",
    "plt.plot(diaMes, valorVenda, 'rD-', label='Valor de Venda')\n",
    "\n",
    "plt.xlabel(\"Dias de setembro\")\n",
    "plt.ylabel(\"Valor do dólar em reais\")\n",
    "plt.title(\"Gráfico da Cotação do Dólar\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Temperatura em São Paulo\n",
    "\n",
    "Escreva um programa para gerar um gráfico com as temperaturas máximas e míninas em São Paulo nos primeiros sete dias de setembro deste ano. Use a tabela abaixo (Fonte: https://www.accuweather.com/pt/br/sao-paulo/45881/september-weather/45881?monyr=9/1/2017&view=table).\n",
    "\n",
    "\n",
    "|Data      | Max/Min  |\n",
    "|:--------:|----------|\n",
    "|sex 01/09 | 23°/14°  |\n",
    "|sáb 02/09 | 25°/14°  |\n",
    "|dom 03/09 | 27°/13°  |\n",
    "|seg 04/09 | 28°/13°  |\n",
    "|ter 05/09 | 28°/12°  |\n",
    "|qua 06/09 | 27°/15°  |\n",
    "|qui 07/09 | 28°/14°  |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Usando o pacote NumPy\n",
    "\n",
    "\n",
    "Como fazer o gráfico da função seno em Python?\n",
    "\n",
    "Para fazer gráficos mais complicados é muito útil o **NumPy**, que é o pacote fundamental para a computação científica em Python. Essa biblioteca permite trabalhar com arranjos, vetores e matrizes de $N$ dimensões (de forma similar ao Matlab) e fornece diversas funções matemáticas úteis para fazer gráficos. Além disso, esse módulo inclui uma variedade de rotinas para classificação e seleção de dados, rotinas de álgebra linear, operações de estatística básicas, simulação aleatória e muito mais. Ver https://docs.scipy.org/doc/numpy/user/whatisnumpy.html.\n",
    "\n",
    "Vamos importar a biblioteca <samp>numpy</samp> e dar o \"apelido\" de <samp>np</samp>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, vamos criar uma lista com os números de -$2\\pi$ até $2\\pi$ com diferença de 0.1 e colocar em uma variável **`a`**.\n",
    "O bom aqui é que o **`numpy`** já tem funções que fazem isso para a gente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.arange(-2*np.pi,2*np.pi,0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver como ficou **`a`**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então, note que em **`arange`**, -$2\\pi$ é o número inicial, $2\\pi$ é o número limite (não incluido na lista resultado), e 0.1 é o quanto acrescentamos em cada passo.\n",
    "\n",
    "E para calcular o seno de cada número em **`a`**? De novo, o **`numpy`** já tem isso pronto para a gente. Vamos usar a função **`sin`**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = np.sin(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver como ficou b?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora só falta fazer o gráfico! Vamos chamar o **`matplotlib.pyplot`** pelo seu apelido **`plt`**. \n",
    "\n",
    "Lembre desligar o último gráfico gerado para criar um novo embaixo da célula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.plot(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos personalizar nosso gráfico. \n",
    "\n",
    "Suponha que esse gráfico representa a variação dum sinal ao longo do tempo. Então vamos colocar \"Tempo (s)\" no eixo X:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.xlabel(\"Tempo (s)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que o seu gráfico (acima) foi atualizado com no eixo x. Vamos colocar \"Valor do sinal\" como o nome do eixo Y:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.ylabel(\"Valor do sinal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos colocar um título no gráfico e grade?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.title(\"Acrescente você mesmo o título\")\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você preferir tirar a grade, você pode colocar **`plt.grid(False)`**  ou apagar a linha de código.\n",
    "\n",
    "Talvez você esteja estranhando este gráfico do seno. O gráfico ficou meio \"esticado\", não?\n",
    "Bom, isso porque o **`matplotlib`** tentou escolher uma escala para a gente. \n",
    "Se você quiser que os eixos fiquem na mesma escala, basta digitar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore um pouco o gráfico! Você pode salvar o gráfico num arquivo clicando no símbolo do disquete/salvar. Escreva abaixo código para mostrar no gráfico o cosseno de cada número em **`a`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arrays \n",
    "\n",
    "O **`arange`** do numpy cria um tipo de dado chamado **array**. Veja como as operações com arrays funcionam:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c = np.arange(0,1,0.1)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que você acha que deveria ser **`c+c`**? Veja abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c+c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E **`c*c`**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c*c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então note que em arrays, essas operações são realizadas ponto-a-ponto. \n",
    "E como faríamos a raiz quadrada de cada entrada de c?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.sqrt(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função **`linspace(a, b, N)`** do numpy permite criar um array de $N$ números uniformente distribuidos no intervalo $[a,b]$, incluindo $a$ e $b$. Veja abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d = np.linspace(2, 3, 5)\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os operadores e funções que fornece o pacote **`numpy`**  para trabalhar com arrays, permitem criar diretamente outros arrays sem usar variáveis auxiliares. Veja o seguinte exemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.linspace(0, 12, 100)\n",
    "\n",
    "plt.plot(x, x, label='y=x')\n",
    "plt.plot(x, x**2, label=r'$y=x^2$')    # Usando fórmulas do Latex nos rótulos!\n",
    "plt.plot(x, 2**x, label=r'$y=2^x$')\n",
    "\n",
    "plt.xlabel('Eixo X')\n",
    "plt.ylabel('Eixo Y')\n",
    "\n",
    "plt.title(\"Gráficos de funções\")\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Várias Funções\n",
    "\n",
    "Modifique o programa acima para mostrar o gráfico das funções $\\sqrt{x}, e^x$ e  $x^3+2x$  (use a multiplicação para calcular $x^3$). Coloque as legendas de forma apropriada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Ponto de interseção\n",
    "\n",
    "Escreva um programa para fazer o gráfico das seguintes funções no intervalo $[-2, 2]$ com diferença de 0.1:\n",
    "\n",
    "* a parábola $f(x) = 5x^2 + 3$ em vermelho,\n",
    "* a reta $g(x) = 4 - x$ em azul e\n",
    "* o polinômio $h(x)=-1.5x^4+2x^3+5$  em verde.\n",
    "\n",
    "As três funções têm algum ponto de interseção no intervalo dado?\n",
    "\n",
    "**Dica**: O botão com um quadradinho vazio em baixo do gráfico é uma ferramenta de zoom. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Como fazer um círculo?\n",
    "\n",
    "\n",
    "Uma das formas de desenhar uma circunferência de raio $r$ e centro $(x_0,y_0)$ é usar a função $f:[0,2\\pi]\\to \\mathrm{R}\\times \\mathrm{R}$ definida como:\n",
    "\n",
    "$$f(t)=(\\ x_0+r*cos(t)\\ ,\\ y_0+r*sin(t)\\ )$$\n",
    "\n",
    "\n",
    "\n",
    "Para entender o que faz essa função, considere a circunferência unitária (raio $1$ e centro $(0,0)$). \n",
    "\n",
    "Sabemos que as cordenadas de um ponto sobre essa circunferência que corresponde a um ângulo $t$ será $(\\cos{t}, \\sin{t})$. \n",
    "\n",
    "<img src=\"http://tidia4.ufabc.edu.br/access/content/group/8398384e-4091-4504-9c21-eae9a6a24a61/Unidade%206/unitcircle.png\" width=\"300\"/>\n",
    "\n",
    "Portanto, se fizermos uma variável &nbsp;`t`&nbsp; (que representa o ângulo) variar de $0$ a $2\\pi$ (0 a 365 graus), podemos plotar a circunferência unitária muito facilmente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para plotar uma circunferência de raio $r$, basta multiplicar as cordenadas de cada ponto por $r$. Para mudar o centro, basta somar o valor de $(x_0, y_0)$.\n",
    "\n",
    "Vamos ver como podemos fazer um círculo de raio 5 e centro (1,2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Outra forma de criar um gŕafico e usar outras funções\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "x0, y0, r = 1, 2, 5                      # dados do círculo\n",
    "t = np.arange(0, 2*np.pi, 0.01)          # dominio da função (passo 0.01 para melhorar a precisão)\n",
    "x = x0 + r * np.cos(t)                   # calculando X e Y\n",
    "y = y0 + r * np.sin(t)\n",
    "ax.plot(x, y, 'r-')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "Mas o gráfico mostra uma circunferência (na verdade uma elipse) e não um círculo?! Então vamos preencher e arrumar a escala. Além disso, vamos colocar a grade e um pequeno ponto no centro. Também vamos acrescentar informação usando fórmulas escritas em Latex. Veja o resultado!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "x0, y0, r = 1, 2, 5                      # dados do círculo\n",
    "t = np.arange(0, np.pi * 2.0, 0.01)      # dominio da função\n",
    "x = x0 + r * np.cos(t)                   # calculando X e Y\n",
    "y = y0 + r * np.sin(t)\n",
    "\n",
    "#ax.plot(x, y, 'g-')                     # usando fill no lugar do plot para preencher\n",
    "ax.fill(x, y, 'b-', alpha=0.3)\n",
    "\n",
    "ax.plot([1], [2], 'ob')                  # mostrando o centro\n",
    "\n",
    "plt.axis('equal')                        # arrumando a escala\n",
    "plt.grid(True)                           # grade\n",
    "\n",
    "plt.title(r'$f(\\alpha)=(1+5*\\mathrm{cos}(\\alpha),2+5*\\mathrm{sin}(\\alpha))$')    # Usando fórmulas em Latex\n",
    "plt.text(-0.6, 0.6, r'$t = 0\\ldots 2\\pi$', fontsize=15)\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Pequeno alvo\n",
    "\n",
    "Modifique o programa acima para\n",
    "\n",
    "1. Definir uma função que dado o centro e o radio dum círculo faça o gráfico (<span style=\"color: red;\">Opcional, se você preferir deixe para fazer em casa</span>).\n",
    "2. Leia as coordenadas do centro dum círculo $(X,Y)$, o radio $R1>1$ e um passo $P>1$.\n",
    "3. Usando a função definida em 1 (<span style=\"color: red;\">Opcional</span>), pinte 3 círculos concêntricos com centro em $(X,Y)$ e radios $R1$, $R1+P$ e $R1+2*P$ nas cores azul, vermelha e verde.\n",
    "\n",
    "\n",
    "Dica: Não usar o parâmetro **`alpha`** na função **`fill`**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mostrando o gráfico de forma incremental\n",
    "\n",
    "Em muitas situações, é desejável ir mostrando o gráfico conforme ele está sendo construido. O exemplo a seguir ilustra uma maneira de conseguir isso. Execute a célula abaixo e veja o resultado.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "x = [0,-8, -10, -6, 0, 6, 10, 8, 0]\n",
    "y = [0, 4,   8,  8, 5, 8, 8,  4, 0]\n",
    "x1 = []\n",
    "y1 = []\n",
    "N = len(x)\n",
    "\n",
    "for i in range(0,N):\n",
    "    x1.append(x[i])\n",
    "    y1.append(y[i])\n",
    "    ax.plot(x1, y1, 'go-')\n",
    "    fig.canvas.draw()\n",
    "\n",
    "    if i < N-1:\n",
    "        input(\"Digite qualquer coisa para continuar \")\n",
    "    else: \n",
    "        print(\"Pronto\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Percurso de drone\n",
    "\n",
    "A Amazon deseja acompanhar o percurso que usa um drone para fazer entregas e coletas de produtos. O drone sai da posição de origem $(0,0)$ e faz as entregas e coletas voando até outras posições especificadas por pontos no plano. O serviço termina quando o drone volta à posição de origem. \n",
    "\n",
    "Adapte o programa anterior para ler as posições de entregas e coletas e mostrar, de forma incremental num gráfico, o percurso do drone até voltar à origem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Outros tipos de gráficos: dispersão, pizza e barras\n",
    "\n",
    "\n",
    "Nesta seção vamos aprender como fazer diferentes tipos de gráficos. Um dos mais simples é o **gráfico de dispersão** que como vimos acima pode ser obtido usando diretamente a função **`plot`**.\n",
    "\n",
    "No entanto, o módulo **`matplotlib.pyplot`** inclui a função **`scatter`** que fornece diversas opções específicas para este tipo de gráfico. \n",
    "\n",
    "Veja o exemplo abaixo. Nele, temos usado o módulo **`random`** do pacote  **`numpy`** para gerar arrays de números aleatórios. Em particular, a função **`rand(N)`** cria um array de $N$ valores aleatórios no intervalo $[0.0, 1.0)$.\n",
    "\n",
    "Outros exemplos podem ser encontrados em https://plot.ly/matplotlib/scatter/."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Adaptado de http://matplotlib.org/examples/shapes_and_collections/scatter_demo.html\n",
    "\n",
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "N = 50\n",
    "x1 = np.random.rand(N)\n",
    "y1 = np.random.rand(N)\n",
    "colors = np.random.rand(N)\n",
    "\n",
    "plt.scatter(x1, y1, c=colors,  marker='^')\n",
    "\n",
    "x2 = np.random.rand(N)\n",
    "y2 = np.random.rand(N)\n",
    "\n",
    "plt.scatter(x2, y2,  color='r',  marker='o',  alpha=.4)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O **gráfico de pizza** também pode ser gerado de forma muito simples usando o módulo **`matplotlib.pyplot`**. Para isso, é usada a função **`pie`**.  \n",
    "\n",
    "A área de cada pedaço da pizza é calculada como $\\frac{x}{\\sum x}$. Os pedaços da pizza são desenhados, por padrão, em sentido sentido anti-horário começando no eixo x (ou num ângulo especificado).\n",
    "\n",
    "Veja o exemplo a seguir. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Adaptado de http://matplotlib.org/examples/pie_and_polar_charts/pie_demo_features.html\n",
    "\n",
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Definindo os pedaços da piza\n",
    "\n",
    "labels = ['Norte', 'Nordeste', 'Sudeste', 'Sul', 'Centro-Oeste']\n",
    "sizes = [8.41, 27.79, 42.06, 14.3, 7.44]\n",
    "explode = (0, 0, 0.1, 0, 0)                           # o terceiro pedaço da piza estará separado\n",
    "\n",
    "# Desenhando o gráfico\n",
    "\n",
    "fig1, ax1 = plt.subplots()\n",
    "\n",
    "ax1.pie(sizes, explode, labels, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=180)                  # Começa a colocar os pedaços no ângulo 180°\n",
    "\n",
    "ax1.axis('equal')                                     # Evitando que o círculo fique achatado \n",
    "\n",
    "plt.title('Percentual da população nas cinco regiões brasileiras em 2012 (IBGE)')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício : Conceitos em PI\n",
    "\n",
    "A professora Alice tem os conceitos da sua turma na matéria de PI e quer fazer um gráfico de pizza com os dados. No entanto, ela não gosta de usar Excel nem nenhuma ferramenta similar. \n",
    "\n",
    "Escreva um programa para ajudar a Alice. Seu programa deve ler o número de estudantes com conceito 'A', 'B', 'C', 'D', 'F' e 'O' e mostrar um gráfico de pizza com as porcentagens em cada caso. O pedaço da pizza correspondente ao conceito 'F' deve estar separado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, um **gráfico de barras** pode ser construido usando as funções **`bar`** (barras verticais) ou **`barh`** (barras horizontais). \n",
    "\n",
    "Em ambos casos, o primeiro parâmetro é uma lista das posições no eixo correspondente (X ou Y)  onde as barras serão desenhadas. O segundo parâmetro é uma lista que indica a altura de cada barra. Outros parâmetros podem ser fornecidos como por exemplo a largura das barras e a cor. Ver mais em https://matplotlib.org/devdocs/api/_as_gen/matplotlib.pyplot.bar.html\n",
    "\n",
    "Além disso, as etiquetas das posições das barras podem ser personalizadas.\n",
    "\n",
    "No programa a seguir é usado um gráfico de barras para resolver o Exercício 2: Temperatura em São Paulo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Adaptado de http://matplotlib.org/examples/style_sheets/style_sheets_reference.html\n",
    "    \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "#Dados\n",
    "x = np.arange(7)                                                             # criando um array [0, ..., 6]\n",
    "tmin = [ 14, 14, 13, 13, 12, 15, 14 ]\n",
    "tmax = [ 23, 25, 27, 28, 28, 27, 28 ]\n",
    "width = 0.25\n",
    "\n",
    "#Gráfico\n",
    "ax.bar(x, tmin, width, color='b', label = 'Mínima')\n",
    "ax.bar(x + width, tmax, width, color='r', label = 'Máxima')\n",
    "ax.set_xticks(x + width / 2)\n",
    "ax.set_xticklabels(['sex 1/09', 'sáb 2/09', 'dom 3/09', 'seg 4/09', 'ter 5/09', 'qua 6/09', 'qui 7/09'])        # mudando as etiquetas do eixo X\n",
    "\n",
    "plt.legend()\n",
    "plt.title(\"Temperatura em SP - primeira semana de setembro\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O próxima exemplo ilustra o uso de **`barh`**. Aqui, também temos usado a função  **`randint(a, b, N)`** que cria um array de tamanho $N$ de números inteiros aleatórios no intervalo  $[a, b)$.\n",
    "\n",
    "Outros exemplos podem ser encontrados em https://plot.ly/matplotlib/bar-charts/."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Adaptado de http://matplotlib.org/examples/lines_bars_and_markers/barh_demo.html\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Dados\n",
    "estudantes = ['Ana', 'João', 'Maria', 'Paulo', 'Gisele']\n",
    "numEst = len(estudantes)\n",
    "y_pos = np.arange(numEst)                                    # criando um array [0, ..., numEst-1]\n",
    "nota = np.random.randint(0, 11, numEst)                      # gerando notas aleatórias entre 0..10 para cada estudante\n",
    "\n",
    "# Gráfico\n",
    "ax.barh(y_pos, nota, align='center', color='blue')\n",
    "ax.set_yticks(y_pos)\n",
    "ax.set_yticklabels(estudantes)\n",
    "ax.set_xlabel('Notas')\n",
    "ax.set_title('Resultados P1')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Exercícios para casa\n",
    "\n",
    "Tente definir e usar funções sempre que possível.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício : Conceitos em PI (parte II)\n",
    "\n",
    "Para deixar mais feliz à professora Alice, você quer melhorar seu programa do exercício anterior e incluir um gráfico de barras horizontais. Adapte o programa abaixo para isso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook\n",
    "\n",
    "# Leitura dos dados\n",
    "\n",
    "\n",
    "# Criando dois gráficos\n",
    "fig, (ax0, ax1) = plt.subplots(nrows=2)\n",
    "\n",
    "# Código para criar o gráfico de barras (use ax0, não ax)\n",
    "\n",
    "\n",
    "\n",
    "# Código para criar o gráfico de piza (use ax1, não ax)\n",
    "\n",
    "\n",
    "\n",
    "# Ajustando o espaço entre os gráficos (pode apagar se não precisar)\n",
    "plt.subplots_adjust(hspace=0.5)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Zeros?\n",
    "\n",
    "Escreva um programa que faça um gráfico da função $f(x) = x^4-16x^2+16$ para x de -5 a 5.\n",
    "Coloque a grade. \n",
    "\n",
    "Olhando para o gráfico, para quais valores de $x$ temos $f(x) = 0$?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: CD\n",
    "\n",
    "Faça um programa que gere o gráfico abaixo (25 círculos concêntricos de raios $1, 1.5, \\dots, 13$).\n",
    "<img src=\"http://tidia4.ufabc.edu.br/access/content/group/8398384e-4091-4504-9c21-eae9a6a24a61/Unidade%206/circles.png\">\n",
    "\n",
    "**Dica:** use o comando **`for`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Sorriso maroto\n",
    "\n",
    "Escreva um programa para gerar o gráfico abaixo. \n",
    "\n",
    "<img src=\"http://tidia4.ufabc.edu.br/access/content/group/8398384e-4091-4504-9c21-eae9a6a24a61/Unidade%208/smile.png\"></img>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Tabuleiro de xadrez\n",
    "\n",
    "Escreva um programa para desenhar um gráfico com um tabuleiro de xadrez de tamanho 4X4. Cada casa do tabuleiro deve ter  tamanho 1x1. Escolha a posição no plano que desejar para fazer o desenho."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Lançamento dum dado\n",
    "\n",
    "Escreva um programa que simule 1000 vezes o lançamento dum dado e conte, nesse experimento, o número de ocorrências de cada face. O programa deve mostrar o resultado usando um gráfico de pizza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Lançamento de dois dados\n",
    "\n",
    "Escreva um programa que simule 1000 vezes o lançamento de dois dados e conte, nesse experimento, quantas vezes a soma das faces foi igual a 7. \n",
    "\n",
    "O programa também deve fazer um gráfico de dispersão para mostrar a distribuição dos lançamentos. Cada eixo do gráfico vai representar um dado. O gráfico deve mostrar os lançamentos nos quais a soma das faces foi igual a 7 com estilo e cor diferentes dos restantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Buraco\n",
    "\n",
    "Um bêbado está andando num campo aberto. A cada instânte o bêbado dá um passo para frente ou para trás ou para a esquerda ou para a direita com a mesma chance de caminhar em qualquer uma dessas direções. O bêbado parte da origem $(0,0)$. Na posição $(X_b,Y_b)$ tem um buraco muito fundo, do qual o bêbado não conseguiria sair caso caísse nele.  Pede-se fazer um programa para:\n",
    "\n",
    "1. simular o movimento do bêbado por até $N$ passos que avisa se o bêbado cai no buraco ou não. O programa deve ler o tamanho do passo do bêbado além de $N$, $X_b$, $Y_b$ ;\n",
    "2. mostrar um gráfico de forma incremental com o movimento do bêbado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: Forca\n",
    "\n",
    "Escreva um programa que desenhe um gráfico do jogo da forca. Veja a imagem abaixo como exemplo. No entanto, seu gráfico não precisa ser similar à imagem. Seja criativ@!\n",
    "    \n",
    "<img src=\"http://professor.ufabc.edu.br/~mirtha.lina/images/forca.png\"></img>\n",
    "\n",
    "<span style=\"color: red;\">**Atenção: Este exercício é de entrega obrigatória para a próxima aula.** </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode inserir mais células de código pelo menu **_Insert &raquo; Insert Cell Below_**, ou digitando <samp>ESC+B</samp>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": {
  "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
}