14.Arquivos Texto e Binários.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\" style=\"margin-top: 1em;\"><ul class=\"toc-item\"><li><span><a href=\"#Arquivos-Texto\" data-toc-modified-id=\"Arquivos-Texto-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Arquivos Texto</a></span><ul class=\"toc-item\"><li><span><a href=\"#Escrevendo-em-um-arquivo-texto\" data-toc-modified-id=\"Escrevendo-em-um-arquivo-texto-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Escrevendo em um arquivo texto</a></span></li><li><span><a href=\"#Escrevendo-números-em-um-arquivo-texto\" data-toc-modified-id=\"Escrevendo-números-em-um-arquivo-texto-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Escrevendo números em um arquivo texto</a></span></li><li><span><a href=\"#Lendo-dados-de-um-arquivo-texto\" data-toc-modified-id=\"Lendo-dados-de-um-arquivo-texto-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Lendo dados de um arquivo texto</a></span></li><li><span><a href=\"#Lendo-números-de-um-arquivo-texto\" data-toc-modified-id=\"Lendo-números-de-um-arquivo-texto-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Lendo números de um arquivo texto</a></span></li></ul></li><li><span><a href=\"#Tratamento-de-exceções\" data-toc-modified-id=\"Tratamento-de-exceções-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Tratamento de exceções</a></span><ul class=\"toc-item\"><li><span><a href=\"#Tipos-de-Erros-mais-comuns\" data-toc-modified-id=\"Tipos-de-Erros-mais-comuns-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Tipos de Erros mais comuns</a></span></li><li><span><a href=\"#Tratando-uma-exceção\" data-toc-modified-id=\"Tratando-uma-exceção-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Tratando uma exceção</a></span></li></ul></li><li><span><a href=\"#Editando-Arquivos-texto\" data-toc-modified-id=\"Editando-Arquivos-texto-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Editando Arquivos texto</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercício\" data-toc-modified-id=\"Exercício-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Exercício</a></span></li></ul></li><li><span><a href=\"#Parâmetros-do-Programa\" data-toc-modified-id=\"Parâmetros-do-Programa-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Parâmetros do Programa</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercícios\" data-toc-modified-id=\"Exercícios-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Exercícios</a></span></li></ul></li><li><span><a href=\"#Arquivos-Binários\" data-toc-modified-id=\"Arquivos-Binários-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Arquivos Binários</a></span><ul class=\"toc-item\"><li><span><a href=\"#Abrindo-Arquivos-Binários\" data-toc-modified-id=\"Abrindo-Arquivos-Binários-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Abrindo Arquivos Binários</a></span></li><li><span><a href=\"#Lendo-e-Escrevendo-em-Arquivos-Binários\" data-toc-modified-id=\"Lendo-e-Escrevendo-em-Arquivos-Binários-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Lendo e Escrevendo em Arquivos Binários</a></span></li><li><span><a href=\"#Exemplo\" data-toc-modified-id=\"Exemplo-5.3\"><span class=\"toc-item-num\">5.3&nbsp;&nbsp;</span>Exemplo</a></span></li><li><span><a href=\"#Exercício\" data-toc-modified-id=\"Exercício-5.4\"><span class=\"toc-item-num\">5.4&nbsp;&nbsp;</span>Exercício</a></span></li></ul></li><li><span><a href=\"#Acessando-e-manipulando-arquivos-e-diretórios-em-disco\" data-toc-modified-id=\"Acessando-e-manipulando-arquivos-e-diretórios-em-disco-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Acessando e manipulando arquivos e diretórios em disco</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Arquivos Texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Até agora, nós vimos no curso, exemplos de programas que obtiveram os dados de\n",
    "entrada de usuários via teclado. A maioria desses programas pode receber seus\n",
    "dados de entrada de arquivos texto também. Um arquivo texto é um objeto de\n",
    "software que armazena dados em um meio permanente, como um disco, CD ou memória\n",
    "flash. Quando comparado à entrada de dados via teclado, as\n",
    "principais vantagens de se obter dados de entrada de um arquivo são as seguintes:\n",
    "- O conjunto de dados pode ser muito maior.\n",
    "- Os dados podem ser inseridos muito mais rapidamente e com menos chance de erro.\n",
    "- Os dados podem ser usados repetidamente com o mesmo programa ou com diferentes programas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Um nome e caminho únicos são usados por usuários ou em programas ou scripts\n",
    "para acessar um arquivo texto para fins de leitura e modificação.\n",
    "As tarefas básicas envolvidas na manipulação de arquivos são ler dados de\n",
    "arquivos e escrever ou anexar dados em arquivos.\n",
    "\n",
    "Leitura e escrita em arquivos em Python são muito fáceis de gerenciar.  No nosso\n",
    "primeiro exemplo, vamos mostrar como ler dados de um arquivo texto. A maneira de\n",
    "dizer ao Python que queremos ler de um arquivo é usar a função `open`. O\n",
    "primeiro parâmetro é o nome do arquivo que queremos ler e com o segundo\n",
    "parâmetro, atribuído ao valor \"r\", afirmamos que queremos ler do arquivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fobj = open(\"files/poema.txt\", \"r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O \"r\" é opcional. Um comando `open` com apenas um nome de arquivo é aberto\n",
    "para leitura por padrão. A função `open` retorna um objeto de arquivo, que\n",
    "oferece métodos e atributos de arquivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dir(fobj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Depois de termos finalizado o trabalho com um arquivo, devemos fechá-lo\n",
    "novamente usando o método do objeto do arquivo `close`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Agora vamos finalmente abrir e ler os dados contidos em um arquivo. O método `rstrip` no exemplo a seguir é usado para retirar os espaços em branco (incluindo o caracter de nova linha ou \\textit{newline}) do lado direito da string \"line\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fobj = open(\"files/poema.txt\")\n",
    "for line in fobj:\n",
    "    print(line.rstrip())\n",
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Escrevendo em um arquivo texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O seguinte código abre um objeto de arquivo de escrita em um arquivo chamado\n",
    "\"files/myfile.txt\". Se o arquivo não existir, ele será criado com o nome do\n",
    "caminho fornecido. Se o arquivo já existe, o Python o abre. Quando os dados são\n",
    "gravados no arquivo e o arquivo é fechado (`close`), todos os dados anteriormente\n",
    "existentes no arquivo são apagados.  Os dados de seqüência de caracteres (strings) são\n",
    "escritos (ou gravados) para um arquivo usando o método de gravação com o objeto de\n",
    "arquivo. O método de escrita espera um único argumento de string. Se você\n",
    "quiser que o texto de saída termine com uma nova linha, você deve incluir o\n",
    "caractere de escape `\\n` na string. O exemplo a seguir escreve duas linhas de\n",
    "texto no arquivo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"files/myfile.txt\", 'w')\n",
    "f.write(\"First line.\\nSecond line.\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Assim como na leitura, quando todas as saídas forem concluídas, o arquivo deve\n",
    "ser fechado usando o método `close`. A falha ao fechar um arquivo de saída pode\n",
    "resultar na perda de dados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Escrevendo números em um arquivo texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Os dados em um arquivo texto podem ser vistos como caracteres, palavras,\n",
    "números ou linhas de texto, dependendo do formato do arquivo texto e dos\n",
    "propósitos para os quais os dados são usados. Quando os dados são tratados como\n",
    "números (inteiros ou pontos flutuantes), eles devem ser separados por espaços\n",
    "em brancos, tabulações ou carateres de mudança de linha. Veja no exemplo abaixo\n",
    "como se parece um arquivo de texto contendo seis números de ponto flutuante\n",
    "quando examinado com um editor de texto. Observe que este formato inclui um\n",
    "espaço ou uma nova linha como um separador de itens no texto."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "34.6 22.33 66.75\n",
    "77.12 21.44 99.01"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Todos os dados de saída ou entrada de um arquivo texto devem ser strings.\n",
    "Assim, os números devem ser convertidos em strings antes da saída, e essas\n",
    "strings devem ser convertidas de volta em números após a entrada.  Em Python,\n",
    "os valores da maioria dos tipos de dados podem ser convertidos em strings\n",
    "usando a função `str`. As strings resultantes são então escritas em um arquivo\n",
    "com espaço ou uma nova linha como um caractere separador.\n",
    "\n",
    "O próximo trecho de código ilustra a saída de inteiros para um arquivo\n",
    "texto. Quinhentos inteiros aleatórios entre 1 e 500 são gerados e escritos em\n",
    "um arquivo texto chamado \"files/integers.txt\". O caractere de \\textit{newline} é o\n",
    "separador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "f = open(\"files/integers.txt\", 'w')\n",
    "for count in range(500):\n",
    "    number = random.randint(1, 500)\n",
    "    f.write(str(number) + \"\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lendo dados de um arquivo texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Existem várias maneiras de ler dados de um arquivo de entrada. A maneira mais simples é usar o método `read` para inserir todo o conteúdo do arquivo como uma seqüência única em um objeto string. Se o arquivo contiver várias linhas de texto, os caracteres de nova linha (\\textit{newline})  serão incorporados nesta string. O exemplo a seguir mostra como usar o método `read`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"../Stuffs/cadastro.py\", 'r')\n",
    "text = f.read()\n",
    "text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Após a conclusão da entrada, outra chamada para ler retornará uma string vazia, para indicar que o final do arquivo foi atingido. Para repetir a leitura em uma entrada, o arquivo deve ser reaberto. Não é necessário fechar o arquivo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Alternativamente, uma aplicação pode ler e processar o texto, uma linha de cada vez. Um laço `for` cumpre isso muito bem. O laço `for` exibe um objeto de arquivo como uma seqüência de linhas de texto. Em cada iteração do laço, a variável de iteração está vinculada à próxima linha de texto na seqüência. No exemplo a seguir, reabrimos o nosso arquivo de exemplo e visitamos as linhas de texto nele contidas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"../Stuffs/cadastro.py\", 'r')\n",
    "for line in f:\n",
    "    print(line.rstrip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Observe que a impressão exibi uma nova linha extra. Isso ocorre porque cada linha de entrada de texto do arquivo mantém seu caractere de \\textit{newline}."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Podemos usar o método `readline` nos casos em que desejamos ler um número especifico de linhas de um arquivo (digamos, a primeira linha somente). O método `readline` consome uma linha de entrada e retorna essa string (incluindo o \\textit{newline}). Se readline encontrar o final do arquivo, ele retorna a string vazia. Revisitamos o exemplo anterior e usamos o laço `while` para inserir todas as linhas de texto com readline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"files/myfile.txt\", 'r')\n",
    "while True:\n",
    "    line = f.readline()\n",
    "    if line == \"\":\n",
    "        break\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lendo números de um arquivo texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Todas as operações de entrada de arquivo retornam dados para o programa como strings. Se essas strings representarem outros tipos de dados, como números inteiros ou números de ponto flutuante, o programador deve convertê-los para os tipos apropriados antes de manipulá-los. Em Python, as representações de seqüência de números inteiros e números de ponto flutuante podem ser convertidas para os próprios números usando as funções `int` e `float`, respectivamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ao ler dados de um arquivo, outra consideração importante é o formato dos itens de dados no arquivo. Anteriormente, mostramos um exemplo de código que emitia números inteiros, escolhidos de forma aleatória, separados por caracteres de \\textit{newline} para um arquivo texto. Durante a entrada, esses dados podem ser lidos com um simples laço `for`. Este laço acessa uma linha de texto em cada iteração. Para converter esta linha para o inteiro contido nele, o programador executa o método `strip` para remover o \\textit{newline} e, em seguida, executa a função `int` para obter o valor inteiro.\n",
    "O exemplo abaixo ilustra essa técnica. Ele abre o arquivo de inteiros aleatórios escrito anteriormente, lê-os e imprime sua soma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"files/integers.txt\", 'r')\n",
    "sum = 0\n",
    "for line in f:\n",
    "    line = line.strip()\n",
    "    number = int(line)\n",
    "    sum += number\n",
    "print(\"The sum is\", sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Obter números de um arquivo texto no qual eles são separados por espaços é um pouco mais complicado. Podemos continuar lendo as linhas em um laço `for`, como antes. Mas cada linha agora pode conter vários números inteiros separados por espaços. Você pode usar o método de seqüência `split` para obter uma lista das cadeias de caracteres que representam esses números inteiros e, em seguida, processar cada seqüência desta lista com outro laço for.\n",
    "\n",
    "Modificamos o exemplo anterior para lidar com números inteiros separados por espaços e/ou caracteres de \\textit{newline}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"files/integers.txt\", 'r')\n",
    "sum = 0\n",
    "for line in f:\n",
    "    wordlist = line.split()\n",
    "    for word in wordlist:\n",
    "        number = int(word)\n",
    "        sum += number \n",
    "print(\"The sum is\", sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tratamento de exceções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Se abrirmos um arquivo para leitura e ele não existir, ocorrerá um erro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "arq = open(\"naoExiste.txt\", \"r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Exceções são eventos inesperados que ocorrem durante a execução de um programa. Uma exceção pode resultar de um erro lógico ou de uma situação imprevista, como no exemplo anterior. Em Python, as exceções (também conhecidas como erros) são objetos que são criados (ou lançados) por código que encontra uma circunstância inesperada. Uma exceção pode ser capturada por um contexto que \"trata\" a exceção de forma apropriada. Se não for detectada, uma exceção faz com que o interpretador Python pare de executar o programa e emita uma mensagem apropriada para o console. Vamos examinar os tipos de erro mais comuns em Python e o mecanismo para capturar e manipular erros que foram gerados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tipos de Erros mais comuns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O Python inclui uma hierarquia rica de classes de exceções que designam várias categorias de erros. Vários desses erros podem ser levantados em casos excepcionais por comportamentos apresentados neste curso. Por exemplo, o uso de um identificador indefinido em uma expressão faz com que seja lançada uma exceção `NameError`. O envio do número, tipo ou valor errados para os parâmetros de uma função é outra causa comum para uma exceção. Por exemplo, uma chamada para `abs(\"hello\")` causará um `TypeError` porque o parâmetro não é numérico e uma chamada para `abs(3, 5)` causará um `TypeError` porque somente um parâmetro é esperado. Normalmente, um `ValueError` é gerado quando o número e tipo de parâmetros corretos são enviados, mas um valor é ilegítimo para o contexto da função. Por exemplo, o construtor `int` aceita uma string, como em `int(\"137\")`, mas um `ValueError` é gerado se essa string não representa um inteiro, como acontece com `int(\"3.14\")` ou `int(\"hello\")`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Os tipos de seqüência de Python (por exemplo, lista, tupla e str) lançam um `IndexError` quando a expressão como `data[k]` é usada com um inteiro $k$ que não é um índice válido para a sequência dada. Os conjuntos e os dicionários lançam um `KeyError` quando uma tentativa é feita para acessar um elemento inexistente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tratando uma exceção"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O objetivo do tratamento de exceções é evitar totalmente a possibilidade de uma exceção ser levantada através do uso de um teste condicional pró-ativo. Na possibilidade de divisão por zero, podemos evitar a situação ofensiva, escrevendo:\n",
    "\n",
    "```\n",
    "if y! = 0:\n",
    "    ratio = x / y\n",
    "else:\n",
    "    ... faça alguma coisa ...\n",
    "```\n",
    "\n",
    "A filosofia, muitas vezes abraçada pelos programadores de Python, é que \"é mais fácil pedir perdão do que obter permissão\". Essa citação é atribuída a Grace Hopper, pioneira em informática. O sentimento é que não precisamos gastar tempo de execução extra salvaguardando contra todos os casos excepcionais, desde que haja um mecanismo para lidar com um problema depois que ele surgir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Em Python, esta filosofia é implementada usando uma estrutura de controle de tentativa-e-erro. Revisando nosso exemplo, a operação de divisão pode ser salvaguardada da seguinte maneira:\n",
    "\n",
    "```\n",
    "try:\n",
    "    ratio = x / y\n",
    "except ZeroDivisionError:\n",
    "    ... faça alguma coisa ...\n",
    "```\n",
    "\n",
    "Nesta estrutura, o bloco \"try\" é o código principal a ser executado. Embora seja um único comando neste exemplo, ele geralmente pode ser um bloco maior de código. O bloco \"try\" pode ser seguido de um ou mais casos \"except\", cada um com um tipo de erro identificado e um bloco de código que deve ser executado se o erro designado for lançado no bloco \"try\".\n",
    "A vantagem relativa de usar uma estrutura de tentativa-e-erro é que o caso não excepcional funciona de forma eficiente, sem verificações estranhas para a condição excepcional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O tratamento de exceções é particularmente útil ao trabalhar com a entrada do usuário, ou ao ler ou escrever para arquivos, porque tais interações são inerentemente menos previsíveis.\n",
    "No nosso exemplo para arquivo inexixtente podemos fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    arq = open(\"files/myfile.txt\", \"r\")\n",
    "    print(\"Abri o arquivo com sucesso.\")\n",
    "except FileNotFoundError:\n",
    "    print(\"Não foi possível abrir o arquivo.\")\n",
    "print(\"fim\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O exemplo abaixo lê um arquivo e mostra o conteúdo dele na tela:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    arq = open(\"files/versos.txt\", \"r\")\n",
    "    while True:\n",
    "        s = arq.read(1)\n",
    "        print(s, end=\"\")\n",
    "        if(s == \"\"):\n",
    "            break\n",
    "    arq.close()\n",
    "except:\n",
    "    print(\"Arquivo versos.txt não pode ser aberto.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Editando Arquivos texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Com o modo de operação \"r+\" (ver tabela abaixo), podemos ler todo o texto de um arquivo e fazer qualquer alteração que julgarmos necessária. O texto alterado pode então ser sobrescrito sobre o texto anterior. Ao realizar a leitura de um caractere, ou uma linha, automaticamente o indicador de posição do arquivo se move para o próximo caractere (ou linha). Para voltar ao início do arquivo novamente você pode usar o método `seek`:\n",
    "```\n",
    "seek(offset, from_what)\n",
    "```\n",
    "onde o primeiro parâmetro indica quantos bytes se mover a partir do valor inicial from_what.\n",
    "Os valores de from_what podem ser:\n",
    "  0: indica início do arquivo.\n",
    "  1: indica a posição atual no arquivo.\n",
    "  2: indica a posição final do arquivo.\n",
    "  \n",
    "Os modos de abertura de arquivo texto e o indicador de posição são:\n",
    " \n",
    " | modo | operações | indicador de posição |\n",
    " | :-:  | :-:       | :-: |\n",
    " | r    | leitura   | início do arquivo    |\n",
    " | r+   | leitura e escrita | início do arquivo |\n",
    " | w    | escrita | início do arquivo |\n",
    " | a    | (append) escrita | final do arquivo |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercício\n",
    "\n",
    "No arquivo poema2.txt existe um tratamento em terceira pessoa quando o autor pretendia que o mesmo fosse em segunda pessoa. Para modificá-lo, procure no texto a palavra \"seu\" e substitua por \"teu\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    f = open(\"files/poema2.txt\", \"r+\")\n",
    "    text = \"\"\n",
    "    while True:\n",
    "        line = f.readline()\n",
    "        if line == \"\":\n",
    "            break\n",
    "        if \"seu\" in line:\n",
    "            line = line.replace(\"seu\", \"teu\")\n",
    "        text += line\n",
    "    f.seek(0, 0)\n",
    "    f.write(text)    \n",
    "    f.close()\n",
    "    print(\"Texto modificado!\")\n",
    "except IOError:\n",
    "    print(\"Problemas no arquivo poema2.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Parâmetros do Programa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "É possível um programa em Python receber parâmetros diretamente da linha de comando quando o programa é executado. Para isso devemos importar o módulo `sys` e ler os dados armazenados na lista `sys.argv`. O primeiro parâmetro na lista `sys.argv` é o nome do arquivo que contém o programa. Os demais parâmetros aparecem na mesma ordem em que foram digitados na linha de comando.\n",
    "O programa abaixo imprime os parâmetros da linha de comando, um por linha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "print(\"Voce executou o programa com \", len(sys.argv), \" parâmetros!\")\n",
    "print(\"Os parâmetros foram\")\n",
    "for p in sys.argv:\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Seu uso é útil em programas onde dados de entrada são passados via linha de comando.\n",
    "Por exemplo, quando os dados a serem processados estão em um arquivo, cujo nome é passado para o programa via linha de comando. O programa a seguir mostra o conteúdo de um arquivo cujo nome do mesmo é passado como parâmetro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "# Just to simulate command line call\n",
    "sys.argv = ['more.py', 'files/poema.txt']\n",
    "# Comment the above line in a real script.\n",
    "\n",
    "if len(sys.argv) != 2:\n",
    "    print(\"Usage: python more.py nome_do_arquivo\")\n",
    "else:\n",
    "    try:\n",
    "        arq = open(sys.argv[1], \"r\")\n",
    "        while True:\n",
    "            t = arq.readline()\n",
    "            print(t, end=\"\")\n",
    "            if t == \"\":\n",
    "                break\n",
    "        arq.close()\n",
    "    except:\n",
    "        print(\"Arquivo não existe!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercícios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**(a) Somando colunas de um arquivo**\n",
    "\n",
    "Suponha que você tenha um arquivo contendo colunas de números gerados por outro sistema e precise somar os números de cada coluna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 5 10 2 1.0\r\n",
      "2 10 20 4 2.0\r\n",
      "3 15 30 8 3\r\n",
      "4 20 40 16 4.0\r\n"
     ]
    }
   ],
   "source": [
    "%cat files/tabela1.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Como já vimos, a divisão de strings é a principal operação por trás da solução desse problema, mas como um bônus adicional, vamos usar a **builtin** `eval` para converter os strings das colunas em números. Ex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "eval(\"x + 1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# solução:\n",
    "import sys\n",
    "\n",
    "def soma(nCols, fileName):\n",
    "    sums = [0] * nCols\n",
    "    for line in open(fileName):\n",
    "        cols = line.split()\n",
    "        for i in range(nCols):\n",
    "            sums[i] += eval(cols[i])\n",
    "    return sums\n",
    "\n",
    "# Just to simulate command line call\n",
    "sys.argv = ['soma1.py', '5', 'files/tabela1.txt']\n",
    "# Comment the above line in a real script.\n",
    "\n",
    "print(soma(eval(sys.argv[1]), sys.argv[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**(b) Somando com `zip` e compreensão de listas**\n",
    "\n",
    "Para este exemplo, os dados estão separados por virgula ao invés de espaço:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,5,10,2,1\r\n",
      "2,10,20,4,2\r\n",
      "3,15,30,8,3\r\n",
      "4,20,40,16,4\r\n"
     ]
    }
   ],
   "source": [
    "%cat files/tabela2.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Iremos utilizar compreensão de listas e a função `zip` para evitar laços aninhados. A **builtin** `zip` usa uma ou mais seqüências como argumentos e retorna uma série de tuplas que emparelham itens paralelos obtidos dessas sequências. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, 5, 6]\n",
    "zipped = zip(x, y)\n",
    "list(zipped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# solução:\n",
    "import sys\n",
    "\n",
    "def soma(nCols, fileName):\n",
    "    sums = [0] * nCols\n",
    "    for line in open(fileName):\n",
    "        cols = line.split(',')\n",
    "        nums = [int(x) for x in cols]\n",
    "        both = zip(sums, nums)\n",
    "        sums = [x + y for (x, y) in both]\n",
    "    return sums\n",
    "\n",
    "# Just to simulate command line call\n",
    "sys.argv = ['soma2.py', '5', 'files/tabela2.txt']\n",
    "# Comment the above line in a real script.\n",
    "\n",
    "print(soma(eval(sys.argv[1]), sys.argv[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(c) Armazenando Dados de Arquivo em Dicionários Aninhados** \n",
    "\n",
    "Recebemos um arquivo de dados com medições de algumas propriedades com nomes dados (aqui A, B, C ...). Cada propriedade é medida por um determinado número de vezes. Os dados são organizados como uma tabela onde as linhas contêm as medidas e as colunas representam as propriedades medidas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  A    B     C    D\r\n",
      "1 11.7 0.035 2017 99.1\r\n",
      "2 9.2  0.037 2019 101.2\r\n",
      "3 12.2 no    no   105.2\r\n",
      "4 10.1 0.031 no   102.1\r\n",
      "5 9.1  0.033 2009 103.3\r\n",
      "6 8.7  0.036 2015 101.9\r\n"
     ]
    }
   ],
   "source": [
    "%cat files/tabela3.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A palavra ```no``` significa nenhum dado, ou seja, falta-nos uma medida. Queremos ler esta tabela em um dicionário de dados para que possamos procurar a medida ```i``` da (digamos) propriedade C como ```data['C'][i]```. Para cada propriedade p, queremos calcular a média de todas as medidas e armazená-las como ```data[p]['mean']```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     8,
     11,
     20,
     24
    ]
   },
   "outputs": [],
   "source": [
    "#solução\n",
    "infile = open('files/tabela3.txt', 'r')\n",
    "lines = infile.readlines()\n",
    "infile.close()\n",
    "data = {}               # data[property][measurement_no] = propertyvalue\n",
    "first_line = lines[0]\n",
    "properties = first_line.split()\n",
    "\n",
    "for p in properties:\n",
    "    data[p] = {}\n",
    "    \n",
    "for line in lines[1:]:\n",
    "    words = line.split()\n",
    "    i = int(words[0])                     # número da medição\n",
    "    values = words[1:]                    # valores das propriedades\n",
    "    for p, v in zip(properties, values):\n",
    "        if v != 'no':\n",
    "            data[p][i] = float(v)\n",
    "                \n",
    "# Computando a média das medidas\n",
    "for p in data:\n",
    "    values = data[p].values()\n",
    "    data[p]['mean'] = sum(values) / len(values)\n",
    "    \n",
    "for p in sorted(data):\n",
    "    print('Valor médio da propiedade %s = %g' % (p, data[p]['mean']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Arquivos Binários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Arquivos podem ter o mais variado conteúdo (imagens, videos, audios, documentos, etc), mas do ponto de vista dos programas existem apenas dois tipos de arquivo:\n",
    "\n",
    "**Arquivo texto:** Armazena caracteres que podem ser mostrados diretamente na tela ou modificados por um editor de textos simples. Exemplos: código fonte Python, documento texto simples, páginas HTML.\n",
    "\n",
    "**Arquivo binário:** Sequência de bits sujeita às convenções dos programas que o gerou, não legíveis diretamente. Exemplos: arquivos executáveis, arquivos compactados, documentos do Office."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A motivação principal é que objetos (como inteiros, listas, dicionários) na sua representação em binário, ocupam pouco espaço na memória, quando comparado com sua representação em formato texto:\n",
    "- Para representarmos o número $123456789.00$ na forma textual, teríamos que convertê-lo para strings e gastaríamos 12 bytes para representar este número.\n",
    "- Sua representação binária, no entanto ocupa sempre 64 bits (ou 8 bytes).\n",
    "\n",
    "Armazenar objetos em arquivos de forma análoga a utilizada em memória permite:\n",
    "- Reduzir o tamanho do arquivo.\n",
    "- Guardar estruturas complexas tendo acesso simples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se você usar um editor de texto para abrir um arquivo binário, você verá quantidades abundantes de caracteres acentuados aparentemente aleatórios e caracteres incomuns, e linhas longas transbordando de texto $-$ este exercício é seguro, mas inútil. No entanto, editar ou salvar um arquivo binário em um editor de texto irá corromper o arquivo, então nunca faça isso. A razão pela qual a corrupção ocorre é porque aplicar uma interpretação do modo de texto irá alterar certas sequências de bytes $-$ como descartar bytes NUL, converter linhas novas, descartar sequências que são inválidas sob uma certa codificação de caracteres, etc. $-$ o que significa que abrir e salvar um arquivo binário Provavelmente produzem um arquivo com bytes diferentes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Abrindo Arquivos Binários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Assim como em arquivos texto, devemos abrir o arquivo com a função `open` e atribuir o objeto arquivo resultante para um nome.\n",
    "Desta forma o nome estará associado ao objeto arquivo, com métodos para leitura e escrita sobre este:\n",
    "```\n",
    "arq = open(\"nome_do_arquivo\", modo)\n",
    "```\n",
    "onde:\n",
    "\n",
    "| modo | operações |\n",
    "| :--: | :--:      |\n",
    "|  rb  | leitura   |\n",
    "|  wb  | escrita   |\n",
    "| r+b  | leitura e escrita |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lendo e Escrevendo em Arquivos Binários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python dispões de vários métodos para ler e escrever em arquivos binários. Nós utilizaremos neste curso o `Pickle`. O módulo `pickle` implementa protocolos binários para serialização e de-serialização de objetos Python. \"\\textit{Pickling}\" é o processo pelo qual uma hierarquia de objetos Python é convertida em um fluxo de bytes, e \"\\textit{Unpickling}\" é a operação inversa, pelo que um fluxo de bytes (de um arquivo binário ou objeto do tipo bytes) é convertido de novo em uma hierarquia de objetos. O \\textit{Pickling} (e o \\textit{Unpickling}) é alternativamente conhecido como \"serialização\", “marshalling,” ou “flattening” no entanto, para evitar confusões, os termos aqui utilizados serão \"\\textit{Pickling}\" e \"\\textit{Unpickling}\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Para escrever um objeto em um arquivo binário usamos o método `pickle.dump`.\n",
    "```\n",
    "pickle.dump(objeto, var_arquivo)\n",
    "```\n",
    "\n",
    "onde: \n",
    "- objeto: este é o objeto a ser salvo em arquivo.\n",
    "- var_arquivo: este é o nome associado a um objeto arquivo previamente\n",
    "aberto em modo binário.\n",
    "\n",
    "Por exemplo, o programa a seguir salva uma lista em arquivo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "try:\n",
    "    arq = open(\"teste.bin\", \"wb\")\n",
    "    lst = [x ** 2 for x in range(10)]\n",
    "    pickle.dump(lst, arq)\n",
    "    arq.close()\n",
    "except IOError:\n",
    "    print(\"Problemas com o arquivo teste.bin\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Para ler um objeto de um arquivo binário usamos o método `pickle.load`.\n",
    "```\n",
    "var_objeto = pickle.load(var_arquivo)\n",
    "```\n",
    "onde:\n",
    "- var arquivo: este é o nome associado a um objeto arquivo previamente aberto em modo binário.\n",
    "- O método automaticamente reconhece o tipo de objeto salvo em arquivo, carrega este para a memória e associa este objeto ao nome var_objeto.\n",
    "\n",
    "O programa a seguir lê a lista previamente salva em arquivo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    arq = open(\"teste.bin\", \"rb\")\n",
    "    lst = pickle.load(arq)\n",
    "    print(lst)\n",
    "    arq.close()\n",
    "except IOError:\n",
    "    print(\"Problemas com o arquivo teste.bin\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exemplo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Neste exemplo, vamos criar um programa que simula um cadastro de alunos de uma turma de MC102. Para representar o aluno vamos criar um dicionário com os campos `nome` e `notas` que irão armazenar, respectivamente, o nome do aluno e as notas dos labs de MC102. Para representar o `cadastro` criaremos um objeto do tipo lista que contém a lista de alunos. Além disso, o programa deverá fornecer um menu de operações com as funções de inserção e remoção do aluno no cadastro, a inserção de notas e a visualização da lista de alunos. No término no programa ele deverá persistir o cadastro para futuras consultas e alterações."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "As funções abaixo implementam as operações básicas do programa, recebendo como parâmetro o cadastro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0,
     7,
     15,
     23
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def CreateAluno(cadastro, nome):\n",
    "    aluno = {}\n",
    "    aluno[\"nome\"] = nome\n",
    "    aluno[\"notas\"] = []\n",
    "    cadastro.append(aluno)\n",
    "\n",
    "\n",
    "def ExcluiAluno(cadastro, nome):\n",
    "    for aluno in cadastro:\n",
    "        if aluno[\"nome\"] == nome:\n",
    "            cadastro.remove(aluno)\n",
    "            return\n",
    "    print(nome, \" não encontrado!\")\n",
    "\n",
    "\n",
    "def InsertNotas(cadastro, nome, notas):\n",
    "    for aluno in cadastro:\n",
    "        if aluno[\"nome\"] == nome:\n",
    "            aluno[\"notas\"] += notas.split()\n",
    "            return\n",
    "    print(nome, \" não encontrado!\")\n",
    "\n",
    "\n",
    "def ListaAlunos(cadastro):\n",
    "    for aluno in cadastro:\n",
    "        for key in aluno:\n",
    "            print(key, \": \", aluno[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O menu de opções é implementado abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def Menu(cadastro):\n",
    "    while True:\n",
    "        print(\"\\nEscolha uma opção:\\n 1- Incluir Aluno\\n 2- Excluir Aluno\")\n",
    "        print(\" 3- Incluir Notas\\n 4- Listar Turma\\n 5- Sair\\n\")\n",
    "        op = int(input())\n",
    "        if op == 1:\n",
    "            nome = input(\"Digite o nome do aluno: \")\n",
    "            CreateAluno(cadastro, nome)\n",
    "        elif op == 2:\n",
    "            nome = input(\"Digite o nome do aluno: \")\n",
    "            ExcluiAluno(cadastro, nome)\n",
    "        elif op == 3:\n",
    "            nome = input(\"Digite o nome do aluno: \")\n",
    "            notas = input(\"Digite as notas do aluno separados por espaço: \")\n",
    "            InsertNotas(cadastro, nome, notas)\n",
    "        elif op == 4:\n",
    "            ListaAlunos(cadastro)\n",
    "        elif op == 5:\n",
    "            return\n",
    "        else:\n",
    "            print(\"Opção inválida!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Finalmente, no programa principal, tratamos a persistencia dos dados em memória de disco para futuro uso do mesmo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "    \n",
    "try:\n",
    "    cadastro = pickle.load(open(\"cadastro.bin\", \"rb\"))\n",
    "    Menu(cadastro)\n",
    "    print(\"\\nSalvando Cadastro...\")\n",
    "    pickle.dump(cadastro, open(\"cadastro.bin\", \"wb\"))\n",
    "except FileNotFoundError:\n",
    "    print(\"Criando Cadastro...\")\n",
    "    cadastro = []\n",
    "    Menu(cadastro)\n",
    "    pickle.dump(cadastro, open(\"cadastro.bin\", \"wb\"))\n",
    "except IOError:\n",
    "    print(\"Problemas no arquivo de cadastro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercício\n",
    "\n",
    "Modifique o cadastro do exemplo anterior para conter a lista de alunos de cada turma de MC102, a saber: ABCD, EF, GHIJ, KLMN, OP, QRST, UZVX, WY, 4567."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Acessando e manipulando arquivos e diretórios em disco"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Os arquivos são organizados em diretórios (também chamados de “pastas”). Cada programa em execução tem um “diretório atual”, que é o diretório-padrão da maior parte das operações. Nos exemplos anteriores, nós abrimos os arquivos tanto para leitura quanto para escrita na pasta \"files\" dentro do diretório atual, que no nosso caso é o diretório onde estão armazenados os cadernos de lições.\n",
    "\n",
    "O módulo `os` de python fornece funções para trabalhar com arquivos e diretórios (“os” é a abreviação de “sistema operacional” em inglês). Por exemplo, `os.getcwd` devolve o nome do diretório atual:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "cwd = os.getcwd()\n",
    "cwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "cwd é a abreviação de “diretório de trabalho atual” em inglês. O resultado neste exemplo é o diretório-padrão do caderno de aulas de MC102 que o jupyter notebook está acessando."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A tabela abaixo fornece algumas das principais funções do módulo os:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| função       | Descrição |\n",
    "| :---         | :---      |\n",
    "| chdir (path) |   Altera o diretório de trabalho atual para o diretório indicado pela variável 'path' |\n",
    "| getcwd ()    |  Retorna o caminho (path) do diretório de trabalho atual |\n",
    "| listdir (path)| Retorna uma lista dos nomes no diretório indicado por 'path' |\n",
    "| mkdir (path) |  Cria um novo diretório e o coloca no diretório de trabalho atual |\n",
    "| remove (path)|  Remove o arquivo indicado por 'path' do diretório de trabalho atual |\n",
    "| rename (old, new) | Renomeia o arquivo ou diretório de 'antigo' para 'novo'|\n",
    "| rmdir (path) |  Remove o diretório de nome 'path' do diretório de trabalho atual|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Por exemplo, se quisermos alterar o diretório atual para a pasta 'files' escrevemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "os.chdir(cwd + \"/files\")\n",
    "cwd = os.getcwd()\n",
    "os.listdir(cwd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Uma string como '/Users/marcio/Unicamp/MC102/Python/lectures/files', que identifica um arquivo ou diretório, é chamada de caminho (path).\n",
    "\n",
    "Um nome de arquivo simples, como \"poema.txt\", também é considerado um caminho, mas é um caminho relativo, porque se relaciona ao diretório atual. Se o diretório atual é '/Users/marcio/Unicamp/MC102/Python/lectures/files', o nome de arquivo 'poema.txt' se refere ao arquivo '/Users/marcio/Unicamp/MC102/Python/lectures/files/poema.txt'.\n",
    "\n",
    "Um caminho que começa com \"/\" não depende do diretório atual; isso é chamado de caminho absoluto. Para encontrar o caminho absoluto para um arquivo, você pode usar `os.path.abspath`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f = os.path.abspath(\"poema.txt\")\n",
    "print(os.path.isfile(f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`os.path` fornece outras funções para trabalhar com nomes de arquivo e caminhos. Por exemplo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| Função | Descrição |\n",
    "| :---          | :---    |\n",
    "| join (path, name) | Une dois ou mais componentes do nome do caminho, inserindo '/' se necessário.| \n",
    "| exists (path) | Retorna True se o caminho existe e False caso contrário |\n",
    "| isdir (path) |  Retorna True se 'path' é um nome de diretório e False caso contrário |\n",
    "| isfile (path) | Retorna True se 'path' é um nome de arquivo e False caso contrário |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Para demonstrar essas funções, o exemplo seguinte “passeia” por um diretório, exibe os nomes de todos os arquivos e chama a si mesmo recursivamente em todos os diretórios:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def walk(dirname):\n",
    "    for name in os.listdir(dirname):\n",
    "        path = os.path.abspath(name)\n",
    "        if os.path.isfile(path):\n",
    "            print(path)\n",
    "        else:\n",
    "            walk(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "os.listdir(cwd)\n",
    "walk(cwd)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "livereveal": {
   "theme": "solarized",
   "transition": "slide"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}