Arquivos.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;\">Manipulação de arquivos</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "Nesta unidade, vamos passar algumas noções sobre manipulação de arquivos (leitura e escrita) e vamos ensinar como usar um módulo do python chamado `csv` para ler uma planilha e exibir os dados dessa planilha usando o `matplotlib.pyplot` que você já conhece.\n",
    "\n",
    "<!-- <span style=\"color: red;\">Lembre-se: execute a última célula para melhorar a aparência deste <i>notebook</i> ou clique no ícone <img style=\"display: inline; width: 28px; margin-top: -5px;\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACcAAAAfCAIAAADr6EOiAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4QoDERoTYL6nigAAAkdJREFUSMftVyFwGkEUfTCXxdwaUIcAZjJBneogEgOmIBJTMEHFpCqIhhpMU9FWxVwMVHQwVTQCKnKYIyYmZJKeOlWSmdyJoojZNbfcDBXJRET0yMyGTKd9auftzn/z3+7fvxuZzWZXV1dBEDDG8MSglCqKsry8HLm8vFxaWkqlUlgIPM+bTqfRIAgWJgkglUoFQRBdgLEPwBiL4jnwL6kqoSuuu292m/ZEhMciWqFx8KmUlKA6sS0bhcbnapaEHBLnyzvDcvxSMiYhVwCavqZnE6Gp6gk4f/e+Ahg7Pxw9E+qwM5GpKsbm3rY5TzSSl+cwiRf3+2cnvb1VFVq5NTjrf8zHoW3ck+lya3A7klmvMVUliFFKCVRKCQilAFET6h1JKCUxSinkOtzbWbdUcC6Ar9vr3dvRt+2X5gNSpsMg6WKtUX+d1wCyUqw1anntnlzVALKyUbudlpgrWansVEtJZFxz6FTrlRJ9MT4aDiv1aimBjGvaP7dqlRLVXXN4LdHhUcfoqIWJdeQK3jG6yJ72RmLSMTpkdWIdudBBABCVSK1XMT5pGjY4BzCymobFOQDXahqn4Bzk0bfEXJWjlVv94+Pv+8U40lvt/nH/YCOO9GZ7cEc+TafzORfwfeYLgDEBwRggOOPwfcaEGNkO83/Z9nhe1cj5+Xkul/uD4umHV7vmzXzR0pvtw7d6yKKLi4vQfY2tvT/sVd2b8P5KSFzLJqWdJprM6knIxP/X2pOrPqZVSPvtRBVF8TxvYZKe5ymKEnmWP91vGHn/laY7sxYAAAAASUVORK5CYII=\" title=\"(run all initialization cells)\"/>.</span> -->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Arquivos\n",
    "\n",
    "Os sistemas operacionais (Windows, Linux, etc.) organizam os dados no disco em forma de arquivos. Os arquivos podem conter imagens, textos, números ou qualquer outro tipo de dado.\n",
    "\n",
    "Nesta unidade, vamos aprender a manipular arquivos de texto, isto é, como acessar arquivos de texto e importar seu conteúdo para dentro de um programa em Python. Também vamos aprender como fazer para gravar dados em um arquivo texto programaticamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Lendo linha por linha\n",
    "\n",
    "Veja o exemplo a seguir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arquivo = open(\"drummond-amor-bicho.txt\")\n",
    "\n",
    "for linha in arquivo:\n",
    "    print(linha)\n",
    "\n",
    "arquivo.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Se você obteve um erro, é porque o arquivo `drummond-amor-bicho.txt` não foi encontrado no diretório corrente (que é o diretório \"Downloads\"). Portanto, baixe o arquivo `drummond-amor-bicho.txt`, salve-o no mesmo diretório que este _notebook_ e execute o código acima novamente.\n",
    "\n",
    "Veja que o conteúdo do arquivo foi exibido na saída do programa acima. \n",
    "\n",
    "O `for` (linha 3) itera sobre as linhas de texto do arquivo e a função `print()` (linha 4) mostra a linha da vez na saída do programa. Uma a uma, as linhas vão sendo impressas até que todo o poema tenha sido mostrado. \n",
    "\n",
    "Repare que as linhas do poema ficaram separadas umas das outras. Isso ocorreu porque, quando uma linha é lida do arquivo o caractere _newline_ no final de cada linha também é lido junto. Além desse _newline_, a função `print()` costuma pular uma linha no final, então mais um _newline_, só que esse _newline_ não estava no arquivo lido e fica sobrando.\n",
    "\n",
    "Para corrigir esse problema, basta mandar a função `print()` não imprimir o _newline_ adicional. Para conseguir isso, trocamos a linha 4 pela chamada `print(linha, end='')`.\n",
    "\n",
    "O programa fica assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arquivo = open(\"drummond-amor-bicho.txt\")\n",
    "\n",
    "for linha in arquivo:\n",
    "    print(linha, end='')\n",
    "\n",
    "arquivo.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para o exemplo seguinte, baixe o arquivo `drummond-leiteiro.txt` e salve-o no mesmo diretório em que este _notebook_ se encontra.\n",
    "\n",
    "Este exemplo servirá para ilustrar que, às vezes, a leitura de um arquivo não funciona exatamente como gostaríamos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arquivo = open(\"drummond-leiteiro.txt\")\n",
    "\n",
    "for linha in arquivo:\n",
    "    print(linha, end=\"\")\n",
    "\n",
    "arquivo.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O erro se deve ao fato de que o arquivo `drummond-leiteiro.txt` não está codificado da maneira que o Python está esperando. \n",
    "\n",
    "Para consultar a codificação desse arquivo, você pode abrir um terminal <kbd>Ctrl+Alt+T</kbd> e navegar até o diretório `Downloads` com o comando `cd ~/Downloads` e depois digitar `file -i *.txt`. Você verá a codificação usada para armazenar os dados em cada arquivo texto após `charset=`.\n",
    "\n",
    "Em vez de abrir um terminal, você pode executar a célula abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "file -i *.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para leitura de arquivos, o Python espera que a codificação seja `utf-8` (ou `ascii`, que é um subconjunto de `utf-8`). Para ler arquivos que possuem codificação diferente, use o parâmetro `encoding` da função `open()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arquivo = open(\"drummond-leiteiro.txt\", encoding=\"iso-8859-1\")\n",
    "\n",
    "for linha in arquivo:\n",
    "    print(linha, end=\"\")\n",
    "\n",
    "arquivo.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>\n",
    "\n",
    "Baixe o arquivo `poe-alone.txt` e faça um programa que imprima o conteúdo desse arquivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lendo tudo de uma vez\n",
    "\n",
    "Também é possível ler o arquivo todo de uma vez e colocar seu conteúdo de texto numa variável. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"drummond-cidadezinha.txt\")\n",
    "texto = f.read()\n",
    "f.close()\n",
    "\n",
    "print(texto, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escrevendo em arquivos\n",
    "\n",
    "Para escrever num arquivo, devemos abrí-lo no modo de escrita e usar o método `write()`.  \n",
    "\n",
    "Veja um exemplo:    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('teste.txt', 'w')\n",
    "\n",
    "f.write('Olá, este é um teste. ')\n",
    "f.write('Para pular linha coloque um \\\\n no final.\\n')\n",
    "f.write('Nunca se esqueça de fechar o arquivo com o método \\'close()\\'.\\n')\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O segundo argumento da função `open()` é `'w'` para indicar que o arquivo está sendo aberto no modo de escrita (_write_ em inglês).\n",
    "\n",
    "Agora minimize esta janela do navegador (minimize o Jupyter) e vá até o gerenciador de arquivos do Ubuntu (procure por Nautilus no menu). Abra o arquivo `teste.txt` com um duplo clique para ver seu conteúdo em um editor de texto comum.\n",
    "\n",
    "Alternativamente, você pode executar a célula abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "mimeopen -n teste.txt "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, se você abrir o mesmo arquivo para escrita novamente e gravar alguns dados com o método `write()`, o novo conteúdo irá sobrescrever o primeiro. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('teste.txt', 'w')\n",
    "\n",
    "f.write('Gravando por cima... apagou tudo.\\n')\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "mimeopen -n teste.txt "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escrevendo no final do arquivo\n",
    "\n",
    "Em programas da vida real, quando queremos escrever em um arquivo, não queremos apagar o que está no arquivo, mas apenas acrescentar conteúdo no final. \n",
    "\n",
    "Para abrir um arquivo com essa finalidade, devemos usar o modo _append_, passando o caractere `'a'` como segundo argumento da função `open()`.\n",
    "\n",
    "veja o exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('teste.txt', 'a')\n",
    "\n",
    "f.write('Essa segunda linha foi gravada sem apagar a primeira.\\n')\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "mimeopen -n teste.txt "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fechando o arquivo automaticamente\n",
    "\n",
    "Sempre que você abre um arquivo (digamos, com a linha `f = open(...)`), seja para leitura ou escrita, você deve fechá-lo com o comando `f.close()` após o términos das operações de entrada e saída. \n",
    "\n",
    "Existe uma estrutura na linguagem Python que permite o fechamento automático de arquivos. Veja o exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('teste.txt', 'a') as meu_arquivo:\n",
    "    meu_arquivo.write('Esta terceira linha foi gravada sem apagar as primeiras.\\n')\n",
    "    meu_arquivo.write('Esta quarta linha também.\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A palavra-chave `with` permite que você faça manipulação do arquivo aberto dentro de um bloco de código (repare na indentação das linhas 2 e 3). Quando o bloco termina, o arquivo `meu_arquivo` é fechado automaticamente. Você pode usar qualquer outro nome de variável no lugar de `meu_arquivo`.\n",
    "\n",
    "Veja como ficou o arquivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "mimeopen -n teste.txt "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para poder fazer o exercício abaixo, é preciso que você se lembre de como usar a função `split()` para dividir um texto em uma lista de textos de acordo com um separador. \n",
    "\n",
    "No exemplo abaixo, o texto é quebrado toda vez que um ponto-e-vírgula for encontrado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = \"550;Fulano de Tal;(11) 934-328-232;fulano@gmail.com\"\n",
    "lista = texto.split(';')\n",
    "print(\"A lista toda:\")\n",
    "print(lista)\n",
    "print('O 2º elemento da lista:')\n",
    "print(lista[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>\n",
    "\n",
    "Faça um programa que é uma agenda de contatos. Quando executado, seu programa deve dar uma lista de opções ao usuário:\n",
    "\n",
    "1. Novo contato\n",
    "2. Mostrar contatos\n",
    "3. Sair\n",
    "\n",
    "Se o usuário selecionar a opção 1, então pergunte ao usuário pelos seguintes dados:\n",
    "\n",
    "* Nome\n",
    "* Telefone\n",
    "* Email\n",
    "\n",
    "e salve este novo contato no final arquivo `contatos.txt`. Cada contato deve corresponder a uma única linha do arquivo e deve possuir o seguinte formato:\n",
    "\n",
    "    ID, Nome, Telefone, Email\n",
    "    \n",
    "O ID deve ser um identificador único daquele contato, que seu programa deve gerar automaticamente. Não se preocupe em evitar entradas duplicadas (mas os IDs devem ser todos diferentes!).\n",
    "\n",
    "Se o usuário selecionar a opção 2, você deve mostrar todos os contatos armazenados. Cada entrada na agenda deve ser impressa na forma\n",
    "\n",
    "       ID: {id do contato}\n",
    "     Nome: {nome do contato}\n",
    "     Tel.: {telefone do contato}\n",
    "    Email: {email do contato}\n",
    "    ---------------------------------\n",
    "    \n",
    "Por exemplo:\n",
    "\n",
    "       ID: 550\n",
    "     Nome: Fulano de Tal\n",
    "     Tel.: (11) 934-328-232\n",
    "    Email: fulano@gmail.com\n",
    "    ---------------------------------\n",
    "\n",
    "Após o término de cada operação seu programa deve voltar a exibir o menu de opções, até que o usuário selecione a opção `Sair`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Planilhas\n",
    "\n",
    "Muitas vezes somos obrigados a trabalhar com planilhas e, nem sempre, os softwares de planilha se comportam da maneira que queremos. Em Python, podemos ler uma planilha que foi salva como um arquivo `.csv` e usar os dados dessa planilha como quisermos!\n",
    "\n",
    "Para manipular arquivos no formato `.csv` existe um módulo de Python que nos será muito útil. Vamos começar aprendendo como ler um arquivo `.csv` e consultar suas entradas, linha a linha.\n",
    "\n",
    "Baixe o arquivo `exemplo.csv` do nosso site e salve-o no mesmo diretório que este _notebook_.\n",
    "\n",
    "Esse arquivo possui muitas entradas (é uma planilha com muitas linhas). Execute a célula a seguir para ver as primeiras 10 linhas desse arquivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "head -10 exemplo.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que a primeira linha possui o cabeçalho (os nomes dos campos) e que as demais linhas são os dados propriamente ditos.\n",
    "\n",
    "Na planilha do exemplo, o cabeçalho tem dois campos (ID Aluno e Nota). Cada uma das linhas seguinte tem dois números: um identificador numérico de aluno e sua nota (de 0 a 100)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "f = open('exemplo.csv', newline='')\n",
    "reader = csv.reader(f)\n",
    "for row in reader:\n",
    "    print(row)\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que cada entrada da planilha ficou agrupada em um único texto. Isso aconteceu porque o delimitador padrão de campos é a vírgula (afinal csv são as iniciais da expressão _comma separated values_). Como o arquivo `exemplo.csv` usa ponto-e-vírgula para separar os campos, precisamos explicitar o delimitador manualmente. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "with open('exemplo.csv', newline='') as f:\n",
    "    reader = csv.reader(f, delimiter=';')\n",
    "    for row in reader:\n",
    "        print(row)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos usar o módulo `matplotlib.pyplot` para fazer um histograma das notas, dividindo-as em 5 intervalos iguais. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "# lista com as notas está inicialmente vazia\n",
    "notas = []\n",
    "\n",
    "# abre o arquivo e acrescenta as notas na lista \n",
    "with open('exemplo.csv', newline='') as f:\n",
    "    linhas = csv.reader(f, delimiter=';') \n",
    "    next(linhas, None)                       # <--- pula 1ª linha (pois é a linha dos cabeçalhos)\n",
    "    for linha in linhas:\n",
    "        notas.append(float(linha[1]))\n",
    "        \n",
    "print(notas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que temos as linhas com as notas, podemos fazer um histograma usando o `matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "num_intervalos = 5\n",
    "plt.hist(notas, num_intervalos)\n",
    "plt.title('Histograma das notas')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para se fazer um histograma, as notas são agrupadas em faixas e, em seguida, conta-se quantas notas cairam em cada faixa. Cada barra do histograma corresponde a uma dessas faixas e sua altura é proporcional ao número de notas em cada faixa.\n",
    "\n",
    "Note que, no histograma acima, não é muito fácil ver os limites de cada faixa. Isso aconteceu porque a função `hist()` não dividiu o intervalo de 0 a 100 em 5 faixas iguais, como esperávamos, mas dividiu um outro intervalo  em 5 faixas. \n",
    "\n",
    "Qual intervalo? \n",
    "\n",
    "O intervalo de números entre a nota mínima e a máxima da lista de `notas`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(notas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(notas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para forçar os limites do histograma a serem 0 e 100, podemos escolher as faixas explicitamente, usando o parâmetro `bins` da função `hist()` que plota histogramas.\n",
    "\n",
    "Basta passarmos a lista de valores que limitam as faixas. Veja o exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "num_intervalos = 5\n",
    "plt.hist(notas, bins=[0, 20, 40, 60, 80, 100])\n",
    "plt.title('Histograma das notas')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos até ter faixas desiguais. Por exemplo, suponha que usamos a seguinte tabela para converter notas em conceitos:\n",
    "\n",
    "| Conceito | Nota |\n",
    "|:-------:|---------:|\n",
    "| A    | de 85 a 100 |\n",
    "| B  | de 70 a 84 |\n",
    "| C  | de 55 a 69 |\n",
    "| D  | de 45 a 54 |\n",
    "| F  | até 44 | \n",
    "\n",
    "Para sabermos quantos alunos conseguiram cada conceito, podemos fazer o seguinte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "num_intervalos = 5\n",
    "plt.hist(notas, bins=[0, 45, 55, 70, 85, 100])\n",
    "plt.title('Histograma das notas')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Olhando para as 5 barras do gráfico acima, percebemos que, aproximadamente, 32 alunos ficaram com F, 10 com D, 20 com C, 15 com B e 11 com A."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>\n",
    "\n",
    "Para este exercício, faça o _download_ da planilha `temperaturas.csv` e salve-a no mesmo diretório que este _notebook_. Essa planilha possui as temperaturas mínimas para cada dia de 2016 medidas numa estação meteorológica em Campos do Jordão.\n",
    "\n",
    "Faça um programa que lê esse arquivo `.csv` e que gera um histograma dessas temperaturas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>\n",
    "\n",
    "Usando a mesma planilha `temperaturas.csv`, você deve fazer um programa que lê essa planilha e que gera um gráfico com essas temperaturas, como estávamos acostumados a fazer na última unidade. O eixo x é o tempo (1 até 366, pois 2016 foi bissexto) e o eixo y são as temperaturas. Consulte o _notebook_ Graficos.ipynb se precisar relembrar da função `plot()` do módulo `matplotlib.pyplot`.\n",
    "\n",
    "Se você quiser, pode deixar este exercício para casa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios para casa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para que você possa fazer o exercício abaixo, precisamos ensinar algumas coisas bem simples de Python.\n",
    "\n",
    "A primeira coisa é sobre procurar um texto dentro de outro. Em Python, podemos usar o operador `in` para verificar se um texto ocorre dentro de outro texto. Veja um exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"rato\" in \"Baratos\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"A\" in \"aa\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que esse operador é _case sensitive_, o que quer dizer que letras maiúsculas e minúsculas são diferenciadas. Por isso, talvez você irá apreciar aprender o método `lower()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"LaTeX\".lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nome = \"Fulano\"\n",
    "print(nome.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"A\".lower() in \"aa\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>\n",
    "\n",
    "Modifique o programa da agenda de contatos para acrescentar as opções\n",
    "\n",
    "1. Novo contato\n",
    "2. Mostrar contatos\n",
    "3. Buscar contato\n",
    "4. Excluir contato\n",
    "3. Sair\n",
    "\n",
    "Agora, se o usuário selecionar a opção 3, você deve perguntar por um texto que será buscado e, em seguida, deverá imprimir todas as entradas do arquivo que possuem aquele texto em algum lugar na linha. Cada entrada que possui o texto buscado deve ser impressa do mesmo modo como foi feito na opção 2, isto é, na forma\n",
    "\n",
    "       ID: {id do contato}\n",
    "     Nome: {nome do contato}\n",
    "     Tel.: {telefone do contato}\n",
    "    Email: {email do contato}\n",
    "    \n",
    "Se o usuário escolher a opção 4 (excluir um contato), peça pelo ID do contato que será excluido e efetue a exclusão."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>\n",
    "\n",
    "Na UFABC temos várias disciplinas que exigem conhecimento de programação. É muito comum que, nesse tipo de disciplina, o professor atribua listas de exercícios de programação. Exercício-programa é um exercício que o aluno precisa fazer um programa para resolver, como os que vocês têm feito neste curso.\n",
    "\n",
    "O problema de mandar os alunos fazerem exercícios-programas é que a correção destes exercícios é uma tarefa extremamente penosa para o professor, pois cada aluno pode fazer o programa de um jeito diferente e o professor precisaria entender cada um deles para poder julgar se cada um está certo ou errado. Existem infinitas formas de se fazer um programa correto.\n",
    "\n",
    "Hoje em dia existem sites que fazem correção automatizada de programas, como o site [URI Online Judge](https://www.urionlinejudge.com.br/) ou o [UVA Online Judge](https://uva.onlinejudge.org/). Esses sites possuem bancos de dados com milhares de problemas de programação, que cobrem conhecimentos de diversas áreas da Ciência da Computação. Lá os alunos podem submeter suas soluções (programas) em várias linguagens de programação. A plataforma recebe o programa-resposta que o usuário enviou e o submete a uma série de testes. Se o programa passar em todos os testes o aluno ganha o crédito por aquele problema, senão ele pode refazer e enviar novamente a (tentativa de) solução para correção, até acertar. \n",
    "\n",
    "Neste exercício, você deve resolver um problema concreto que os professores que utilizam o [URI Online Judge](https://www.urionlinejudge.com.br/) enfrentam. Eles precisam adicionar os alunos de suas turmas (reais) em turmas (virtuais) do URI Online Judge. Cada aluno possui um ID no URI. Na plataforma da URI, o professor pode criar uma turma virtual e adicionar seus alunos passando uma lista de IDs separados por ponto-e-vírgula. \n",
    "\n",
    "Na prática, o professor cria um formulário no Google Forms e pede para os alunos preencherem o formulário com seus dados: nome, número de matrícula na UFABC (o famoso RA), e o ID do URI. Depois que os alunos preenchem o formulário, os dados ficam salvos numa planilha. \n",
    "\n",
    "Neste exercício, você deve baixar a planilha `uri.csv` do nosso site e salvá-la no mesmo diretório que este _notebook_. Depois faça um programa que acessa essa planilha e extrai a lista de todos os IDs do URI. Finalmente, seu programa deve gravar num arquivo de nome `lista.txt` a lista de IDs em uma única linha, separados por ponto-e-vírgula (e sem nenhum espaço entre eles). Assim, para o professor adicionar esses alunos numa turma virtual do URI, basta ele abrir o arquivo `lista.txt` em um editor de texto, copiar todo o conteúdo do arquivo e colar na plataforma do _URI Online Judge_.\n",
    "\n",
    "Boa sorte!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "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"
      ],
      "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>  "
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}