05-entrada-saida.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entrada e Saída de Dados\n",
    "================\n",
    "\n",
    "Nesta seção, descrevemos o processo de impressão na tela, o qual inclui o uso da função `print`, o especificador de formato do estilo antigo `%` e o especificador de formato do novo estilo `{}`.\n",
    "\n",
    "Imprimindo na saída padrão (normalmente a tela)\n",
    "-------------------------------------------------\n",
    "\n",
    "A função `print` é o comando mais usado para imprimir informações para o \"dispositivo de saída padrão\", que normalmente é a tela.\n",
    "\n",
    "Existem dois modos de usar a impressão.\n",
    "\n",
    "### Impressão simples\n",
    "\n",
    "A maneira mais fácil de usar o comando de impressão é listando as variáveis a serem impressas, separadas por vírgulas. Aqui estão alguns exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 'texto de teste'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "texto de teste\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 texto de teste\n"
     ]
    }
   ],
   "source": [
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A resposta é 10\n"
     ]
    }
   ],
   "source": [
    "print(\"A resposta é\", a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A resposta é 10 e a string contém texto de teste\n"
     ]
    }
   ],
   "source": [
    "print(\"A resposta é\", a, \"e a string contém\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A resposta é 10 e a string lida como texto de teste\n"
     ]
    }
   ],
   "source": [
    "print(\"A resposta é\", a, \"e a string lida como\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python, um espaço é adicionado entre cada objeto que está sendo impresso. Uma nova linha é impressa após cada chamada. Para suprimir isso, use o parâmetro `end =`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Imprimindo na linha... ainda imprimindo na mesma linha.\n"
     ]
    }
   ],
   "source": [
    "print(\"Imprimindo na linha\", end ='')\n",
    "print(\"... ainda imprimindo na mesma linha.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Impressão formatada\n",
    "\n",
    "A forma mais sofisticada de formatar a saída usa uma sintaxe muito semelhante ao `fprintf` do Matlab (e, portanto, também, semelhante ao `printf` da linguagem C). A estrutura geral é a de uma *string* contendo especificadores de formato, seguida por um sinal de porcentagem e uma tupla que contém as variáveis a serem impressas no lugar dos especificadores de formato."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 10 b = 20\n"
     ]
    }
   ],
   "source": [
    "print(\"a = %d b = %d\" % (10,20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma *string* pode conter identificadores de formato (ex: `%f` para formatar como `float`,`%d` para formatar como número inteiro e `%s` para formatar como *string*, isto é, uma sequência de caracteres):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi =  3.14\n"
     ]
    }
   ],
   "source": [
    "from math import pi\n",
    "print(\"Pi = %5.2f\" % pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi =      3.142\n"
     ]
    }
   ],
   "source": [
    "print(\"Pi = %10.3f\" % pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi = 3.14159265\n"
     ]
    }
   ],
   "source": [
    "print(\"Pi = %10.8f\" % pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi = 3\n"
     ]
    }
   ],
   "source": [
    "print(\"Pi = %d\" % pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O especificador de formato do tipo `%W.Df` significa que um `float` deve ser impresso com uma largura total de *W* caracteres e *D* digitos após o ponto decimal. (Isto é idêntico ao Matlab e C, por exemplo).\n",
    "\n",
    "Para imprimir mais de um objeto, forneça vários especificadores de formato e liste vários objetos na tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi = 3.141593, 142*pi = 446.106157 e pi^2 = 9.869604.\n"
     ]
    }
   ],
   "source": [
    "print(\"Pi = %f, 142*pi = %f e pi^2 = %f.\" % (pi,142*pi,pi**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que a conversão de um especificador de formato e uma tupla de variáveis para uma *string* não depende do comando `print`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pi = 3.141593'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi\n",
    "\"pi = %f\" % pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso significa que podemos converter objetos em *strings* onde quer que precisemos, e podemos decidir imprimir as *strings* mais tarde - não há necessidade de acoplar a formatação ao código que faz a impressão.\n",
    "\n",
    "Visão geral dos especificadores de formato comumente usados (exemplo: unidade astronômica):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'149597870700.000000'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AU = 149597870700  # unidade astronomica [m]\n",
    "\"%f\" % AU          # linha1 na tabela"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| especificador     |         estilo        |examplo da saída para AU|\n",
    "|:------------------|:---------------------:|-----------------------:|\n",
    "| `%f` |     ponto flutante          |  `149597870700.000000`|\n",
    "| `%e` |  notação exponencial        |         `1.495979e+11`|\n",
    "| `%g` |  mais curta entre `%e` ou `%f`|          `1.49598e+11`|\n",
    "| `%d` |        inteiro              |         `149597870700`|\n",
    "| `%s` |  `str()` |         `149597870700`|\n",
    "| `%r` | `repr()` |        `149597870700L`|\n",
    "\n",
    "### `str` e `__str__`\n",
    "\n",
    "Todos os objetos em Python devem fornecer um método `__str__` que retorne uma boa representação de *string* do objeto. Este método `a.__str__()` é chamado quando aplicamos a função `str` ao objeto `a`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.14'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3.14\n",
    "a.__str__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.14'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função `str` é extremamente conveniente já que nos permite escrever objetos mais complicados, tais como"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"[3, 4.2, ['maçã', 'banana'], (0, 1)]\""
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = [3, 4.2, ['maçã', 'banana'], (0, 1)]\n",
    "str(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A forma como isto é impresso em Python é usando o método `__str__` do objeto da lista. O interpretador imprimirá o colchete de abertura `[` e depois chamará o método `__str__` do primeiro objeto, ou seja, o inteiro 3, produzindo `3`. Em seguida, o método `__str__` do objeto da lista imprime a vírgula `,`,  move-se para chamar o método `__str__` do próximo elemento da lista (ou seja,`4.2`) para imprimi-lo. Desta forma, qualquer objeto composto pode ser representado como uma *string*, pedindo aos objetos que ele guarda para convertê-los em *strings*.\n",
    "\n",
    "O método *string* do objeto `x` é chamado de forma implícita quando\n",
    "\n",
    "- usamos o especificador de formato `%s` para imprimir `x`;\n",
    "\n",
    "- passamos o objeto `x` diretamente para o comando de impressão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4.2, ['maçã', 'banana'], (0, 1)]\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4.2, ['maçã', 'banana'], (0, 1)]\n"
     ]
    }
   ],
   "source": [
    "print(\"%s\" % b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `repr` e ` __repr__`\n",
    "\n",
    "Uma segunda função, `repr`, deve converter um determinado objeto em uma representação de string *para que essa sequencia de caracteres possa ser usada para recriar o objeto usando a função `eval`*. A função `repr` geralmente fornecerá uma string mais detalhada do que `str`. A aplicação de `repr` ao objeto `x` tentará chamar `x.__repr__()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.141592653589793'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi as a1\n",
    "str(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.141592653589793'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numero_como_string = repr(a1)\n",
    "a2 = eval(numero_como_string)  # avalia a string \n",
    "a2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2-a1                      # -> repr é uma representação exata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1-eval(repr(a1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1-eval(str(a1))           # -> str perdeu alguns dígitos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos converter um objeto para a sua forma `str()` ou `repr()` usando os especificadores de formato `%s` e `%r`, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.141592653589793'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\"%s\" % math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.141592653589793'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"%r\" % math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nova formatação\n",
    "\n",
    "Um novo sistema predefinido de formatação permite mais flexibilidade para casos complexos, com o custo de ser um pouco mais longo.\n",
    "\n",
    "Idéias básicas em exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pedro precisa de 4 chocolates'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{} precisa de {} chocolates\".format('Pedro', 4)     # insere valores na ordem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pedro precisa de 4 chocolates'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{0} precisa de {1} chocolates\".format('Pedro', 4)   # indexa elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4 precisa de Pedro chocolates'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{1} precisa de {0} chocolates\".format('Pedro', 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pedro precisa de 4 chocolates'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# referencia elemento para impressão por nome\n",
    "\"{nome} precisa de {numero} chocolates\".format(nome='Pedro',numero=4)               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pi é aproximadamente 3.141593.'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Pi é aproximadamente {:f}.\".format(math.pi)     # podemos usar opções de formatação no estilo antigo para float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pi é aproximadamente 3.14.'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Pi é aproximadamente {:.2f}.\".format(math.pi)   # e precisao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pi é aproximadamente   3.14.'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Pi é aproximadamente {:6.2f}.\".format(math.pi)  # e largura"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Esta é uma maneira poderosa e elegante de formatação de *strings* que está tendo seu uso crescendo gradualmente.\n",
    "\n",
    "##### Outras informações\n",
    "\n",
    "- [Exemplos](http://docs.python.org/library/string.html#format-examples)\n",
    "\n",
    "- [Python Enhancement Proposal 3101](http://www.python.org/dev/peps/pep-3101/)\n",
    "\n",
    "- [Biblioteca Python, String Formatting Operations](http://docs.python.org/library/stdtypes.html#string-formatting-operations)\n",
    "\n",
    "- [Formatação antiga de *strings*](http://docs.python.org/tutorial/inputoutput.html#old-string-formatting)\n",
    "\n",
    "- [Introdução à formatação de saída mais elegante, tutorial Python, seção 7.1](http://docs.python.org/tutorial/inputoutput.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mudanças de Python 2 para Python 3: `print`\n",
    "\n",
    "Uma (talvez a mais óbvia) mudança da versão Python 2 para a 3 é perda do status especial do comando `print`. Em Python 2, poderíamos imprimir \"Hello world\" usando:\n",
    "\n",
    "```python\n",
    "print \"Hello world\"             # válida em Python 2.x\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Efetivamente, chamamos a função `print` com o argumento `Hello World`. Todas as outras funções em Python são chamadas com o argumento acompanhado por parênteses, i.e."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")               # válida em Python 3.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta é a nova convenção *necessária* em Python 3 e *permitida* para a versão recente de Python 2.x.\n",
    "\n",
    "Tudo o que aprendemos sobre a formatação de *strings* usando o operador de porcentagem ainda funciona da mesma maneira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'meu pi = 3.141593'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "a = math.pi\n",
    "\"meu pi = %f\" % a           # formatação de string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "meu pi = 3.141593\n"
     ]
    }
   ],
   "source": [
    "print(\"meu pi = %f\" % a)    # impressão valida em Python 2.7 e 3.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Curto pi = 3.14, mais longo pi = 3.141592653590.'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Curto pi = %.2f, mais longo pi = %.12f.\" % (a, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Curto pi = 3.14, mais longo pi = 3.141592653590.\n"
     ]
    }
   ],
   "source": [
    "print(\"Curto pi = %.2f, mais longo pi = %.12f.\" % (a, a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Curto pi = 3.14, mais longo pi = 3.141592653590.\n"
     ]
    }
   ],
   "source": [
    "print(\"Curto pi = %.2f, mais longo pi = %.12f.\" % (a, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Leitura e escrita de arquivos\n",
    "-------------------------\n",
    "\n",
    "Aqui está um programa que\n",
    "\n",
    "1. escreve algum texto para um arquivo com o nome `teste.txt`,\n",
    "\n",
    "2. e depois lê o texto novamente e\n",
    "\n",
    "3. imprime na tela.\n",
    "\n",
    "Os dados armazenados no arquivo `teste.txt` são:\n",
    "\n",
    "```\n",
    "Escrevendo texto no arquivo. Esta é a primeira linha.\n",
    "E a segunda linha.\n",
    "```\n",
    "\n",
    "<!-- -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escrevendo texto no arquivo. Esta é a primeira linha.\n",
      "E a segunda linha.\n"
     ]
    }
   ],
   "source": [
    "# 1. Escrever um arquivo \n",
    "out_file = open(\"teste.txt\", \"w\")         # 'w' significa Writing (modo de escrita)\n",
    "out_file.write(\"Escrevendo texto no arquivo. Esta é a primeira linha.\\n\"+\\\n",
    "               \"E a segunda linha.\")\n",
    "out_file.close()                          # fecha o arquivo\n",
    " \n",
    "# 2. Ler um arquivo\n",
    "in_file = open(\"teste.txt\", \"r\")          # 'r' significa Reading (modo de leitura)\n",
    "text = in_file.read()                     # lê todo o arquivo em na string 'text'\n",
    "                                          \n",
    "in_file.close()                           # fecha o arquivo\n",
    " \n",
    "# 3. Mostrar os dados\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais detalhadamente, abrimos um arquivo com o comando `open` e atribuimos este objeto de abertura de arquivo à variável `out_file`. Depois, escrevemos dados no arquivo usando o método `out_file.write`. Observe que, no exemplo acima, passamos uma *string* para o método `write`. Podemos, naturalmente, usar toda a formatação que discutimos antes. Por exemplo, para escrever este arquivo com o nome `tabela.txt`, podemos usar este programa Python. É uma boa prática fechar (`close()`) arquivos quando terminamos de operar em modo de leitura ou escrita. Se um programa Python for encerrado de forma controlada (ou seja, não por causa de um corte de energia ou de um *bug* improvável profundo na linguagem Python ou no sistema operacional), ele fechará todos os arquivos abertos assim que os objetos de manipulação de arquivo forem destruídos. No entanto, fechá-los ativamente o mais rápido possível é um estilo melhor.\n",
    "\n",
    "### Exemplos de leitura de arquivos\n",
    "\n",
    "Usamos um arquivo chamado `meu-arquivo.txt` contendo as seguintes 3 linhas de texto para os exemplos abaixo:\n",
    "\n",
    "    Esta é a primeira linha.\n",
    "    Esta é a segunda linha.\n",
    "    Esta é uma terceira e última linha.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f = open('meu-arquivo.txt', 'w')\n",
    "f.write('Esta e a primeira linha.\\n'\n",
    "        'Esta e a segunda linha.\\n'\n",
    "        'Esta e uma terceira e ultima linha.')\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### fileobject.read()\n",
    "\n",
    "O método `fileobject.read()` lê o arquivo inteiro e o retorna como uma *string* (incluindo caracteres de nova linha - `\\n`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Esta e a primeira linha.\\nEsta e a segunda linha.\\nEsta e uma terceira e ultima linha.'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = open('meu-arquivo.txt', 'r')\n",
    "f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### fileobject.readlines()\n",
    "\n",
    "O método `fileobject.readlines()` retorna uma lista de *strings*, onde cada elemento da lista corresponde a uma linha na *string*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Esta e a primeira linha.\\n',\n",
       " 'Esta e a segunda linha.\\n',\n",
       " 'Esta e uma terceira e ultima linha.']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = open('meu-arquivo.txt', 'r')\n",
    "f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isto é frequentemente usado para iterar nas linhas, e para fazer alguma coisa com cada linha. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 caracteres\n",
      "24 caracteres\n",
      "35 caracteres\n"
     ]
    }
   ],
   "source": [
    "f = open('meu-arquivo.txt', 'r')\n",
    "for line in f.readlines():\n",
    "    print(\"%d caracteres\" % len(line))\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que isso irá ler o arquivo completo em uma lista de *strings* quando o método `readlines ()` for chamado. Isso não é problema se sabemos que o arquivo é pequeno e se encaixa na memória da máquina.\n",
    "\n",
    "Se assim for, também podemos fechar o arquivo antes de processarmos os dados, ou seja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 caracteres\n",
      "24 caracteres\n",
      "35 caracteres\n"
     ]
    }
   ],
   "source": [
    "f = open('meu-arquivo.txt', 'r')\n",
    "lines = f.readlines()\n",
    "f.close()\n",
    "for line in lines:\n",
    "    print(\"%d caracteres\" % len(line))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterando em linhas (objeto arquivo)\n",
    "\n",
    "Existe uma possibilidade mais legal de ler uma linha de arquivo por linha que (i) somente lerá uma linha por vez (e também é adequada para arquivos grandes) e (ii) resulta em código mais compacto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 caracteres\n",
      "24 caracteres\n",
      "35 caracteres\n"
     ]
    }
   ],
   "source": [
    "f = open('meu-arquivo.txt', 'r')\n",
    "for line in f:\n",
    "    print(\"%d caracteres\" % len(line))\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aqui, o manipulador de arquivo `f` atua como um iterador e retornará a próxima linha em cada iteração subsequente do laço `for` até o final do arquivo ser alcançado (e então o laço `for` é encerrado).\n",
    "\n",
    "##### Leitura adicional\n",
    "\n",
    "[Métodos para arquivos, Tutorial, Seção 7.2.1](http://docs.python.org/tutorial/inputoutput.html#methods-of-file-objects)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}