5.entrada_saida.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Entrada e Saída"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existem várias maneiras de apresentar a saída de um programa; os dados podem ser exibidos em forma legível para seres humanos, ou escritos em arquivos para uso posterior."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Refinando a Formatação de Saída"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Até agora vimos duas maneiras de exibir valores: expressões e a função [print()](https://docs.python.org/pt-br/3/library/functions.html#print). (Uma outra maneira é utilizar o método `write()` de objetos do tipo arquivo; o arquivo saída padrão pode ser referenciado como `sys.stdout`. Veja a Referência da Biblioteca Python para mais informações sobre isso)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Muitas vezes se deseja mais controle sobre a formatação da saída do que simplesmente exibir valores separados por espaço. Existem várias maneiras de formatar a saída.\n",
    "\n",
    "- para usar strings literais formatadas, comece uma string com `f` ou `F`, antes de abrir as aspas ou aspas triplas. Dentro dessa string, pode-se escrever uma expressão Python entre caracteres `{` e `}`, que podem se referir a variáveis, ou valores literais;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ano = 2022\n",
    "evento = 'Copa do Mundo'\n",
    "print(f'Resultados da {evento} no ano {ano}.')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- o método de strings [str.format()](https://docs.python.org/pt-br/3/library/stdtypes.html#str.format) requer mais esforço manual. Ainda será necessário usar `{` e `}` para marcar onde a variável será substituída e pode-se incluir diretivas de formatação detalhadas, mas também precisará incluir a informação a ser formatada;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "voto_sim = 42_572_654\n",
    "voto_nao = 43_132_495\n",
    "percentual = voto_sim / (voto_sim + voto_nao)\n",
    "print('{:-9} votos SIM {:2.2%}'.format(voto_sim, percentual))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- finalmente, pode-se fazer todo o tratamento da saída usando as operações de fatiamento e concatenação de strings para criar qualquer layout que se possa imaginar. O tipo string possui alguns métodos que realizam operações úteis para preenchimento de strings para uma determinada largura de coluna;"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando não é necessário sofisticar a saída, mas apenas exibir algumas variáveis com propósito de depuração, pode-se converter qualquer valor para uma string com as funções [repr()](https://docs.python.org/pt-br/3/library/functions.html#repr) ou [str()](https://docs.python.org/pt-br/3/library/stdtypes.html#str)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função [str()](https://docs.python.org/pt-br/3/library/stdtypes.html#str) serve para retornar representações de valores que sejam legíveis para as pessoas, enquanto [repr()](https://docs.python.org/pt-br/3/library/functions.html#repr) é para gerar representações que o interpretador Python consegue ler (ou levantará uma exceção [SyntaxError](https://docs.python.org/pt-br/3/library/exceptions.html#SyntaxError), se não houver sintaxe equivalente). Para objetos que não têm uma representação adequada para consumo humano, [str()](https://docs.python.org/pt-br/3/library/stdtypes.html#str) devolve o mesmo valor que [repr()](https://docs.python.org/pt-br/3/library/functions.html#repr). Muitos valores, tal como números ou estruturas, como listas e dicionários, têm a mesma representação usando quaisquer das funções. Strings, em particular, têm duas representações distintas.\n",
    "\n",
    "Alguns exemplos :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = 'bem vindo'\n",
    "print(str(string))\n",
    "print(repr(string))\n",
    "print(str(1/7))\n",
    "\n",
    "x = 10 * 3.25\n",
    "y = 200 * 200\n",
    "s = 'O valor de x é ' + repr(x) + ', e y é ' + repr(y) + '...'\n",
    "print(s)\n",
    "# O repr() d euma string adiciona aspas e contra-barra à string\n",
    "ola = 'olá, mundo\\n'\n",
    "olas = repr(ola)\n",
    "print(olas)\n",
    "# O argumento para o repr() pode ser um objeto Python\n",
    "repr((x, y, ('spam', 'ovos')))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O módulo [string](https://docs.python.org/pt-br/3/library/string.html#module-string) contém uma classe [Template](https://docs.python.org/pt-br/3/library/string.html#string.Template) que oferece ainda outra maneira de substituir valores em strings, usando espaços reservados como `$x` e substituindo-os por valores de um dicionário, mas oferece muito menos controle da formatação."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1. Strings Literais Formatadas"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Leitura e Escrita de Arquivos"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função [open()](https://docs.python.org/pt-br/3/library/functions.html#open) retorna um objeto arquivo, e é mais utilizado com dois argumentos posicionais e um argumento nomeado: `open(filename, mode, encoding=None)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('resultado.txt', 'w', encoding=\"utf-8\")\n",
    "arq.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O primeiro argumento é uma string contendo o nome do arquivo. O segundo argumento é outra string, contendo alguns caracteres que descrevem o modo como o arquivo será usado.\n",
    "- `r` quando o arquivo será apenas lido;\n",
    "- `w` para escrever (se o arquivo já existir seu conteúdo prévio será apagado);\n",
    "- `a` para abrir o arquivo para adição e qualquer escrita será adicionada ao final do arquivo;\n",
    "- `r+` abre o arquivo tanto para leitura como para escrita;\n",
    "\n",
    "O argumento modo é opcional, em caso de omissão será assumido `r`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normalmente, arquivos são abertos no modo texto, o que significa que você lê strings de e para o arquivo, o qual está em um codificação específica. Se a codificação não for especificada, o padrão irá depender da plataforma. Como o UTF-8 é o padrão mais moderno, `encoding=\"utf-8\"` é recomendado a não ser que você precise utilizar uma codificação diferente.\n",
    "\n",
    "Adicionando `b` ao modo irá abrir o arquivo em modo binário. Dados no modo binário são lidos e escritos como objetos bytes. Você não pode especificar a codificação quando estiver abrindo os arquivos em modo binário."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em modo texto, o padrão durante a leitura é converter terminadores de linha específicos da plataforma (`\\n` no Unix, `\\r\\n` no Windows) para apenas `\\n`. Ao escrever no modo de texto, o padrão é converter as ocorrências de \\n de volta para os finais de linha específicos da plataforma. Essa modificação de bastidores nos dados do arquivo é adequada para arquivos de texto, mas corromperá dados binários, como arquivos `JPEG` ou `EXE`. Tenha muito cuidado para só usar o modo binário, ao ler e gravar esses arquivos."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É uma boa prática usar a palavra-chave `with` ao lidar com arquivos. A vantagem é que o arquivo é fechado corretamente após o término de sua utilização, mesmo que uma exceção seja levantada em algum momento. Usar `with` também é muito mais curto que escrever seu bloco equivalente `try...except...finally`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depois que um arquivo é fechado, seja por uma instrução `with` ou chamando `arq.close()`, as tentativas de usar o arquivo falharão automaticamente."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Métodos de Objetos Arquivo"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para simplificar, vamos usar o arquivo `aneis_poder.txt` para os exemplos."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ler o conteúdo de um arquivo, chamamos `arq.read(tamanho)`, que lê um punhado de dados devolvendo-os como uma string (em modo texto) ou bytes (em modo binário). `tamanho` é um argumento numérico opcional.<br>\n",
    "Quando tamanho é omitido ou negativo, todo o conteúdo do arquivo é lido e devolvido; se o arquivo é duas vezes maior que memória da máquina, o problema é seu (ta aí um bom desafio...). Caso contrário, o máximo tamanho de caracteres (em modo texto) ou tamanho bytes (em modo binário) são lidos e devolvidos. Se o fim do arquivo for atingido, f.read() devolve uma string vazia ('')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('aneis_poder.txt', 'r', encoding='utf-8')\n",
    "print(arq.read())\n",
    "arq.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O método `arq.readline()` lê uma única linha do arquivo; o caractere de quebra de linha (`\\n`) é mantido ao final da string, e só é omitido na última linha do arquivo, se o arquivo não terminar com uma quebra de linha. Isso elimina a ambiguidade do valor retornado; se `arq.readline()` retorna uma string vazia, o fim do arquivo foi atingido. Linhas em branco são representadas por um `\\n` – uma string contendo apenas o caractere terminador de linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('aneis_poder.txt', 'r', encoding='utf-8')\n",
    "print(arq.readline())\n",
    "print(arq.readline())\n",
    "arq.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma maneira alternativa de ler linhas do arquivo é iterar diretamente pelo objeto arquivo. É eficiente, rápido e resulta em código mais simples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('aneis_poder.txt', 'r', encoding='utf-8')\n",
    "for linha in arq:\n",
    "    # marcamos o end como '' para não imprimir linhas em branco pela repetição \n",
    "    # do \\n do arquivo e do print\n",
    "    print(linha, end='')\n",
    "arq.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se desejar ler todas as linhas de um arquivo em uma lista, pode-se usar `list(arq)` ou `arq.readlines()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('aneis_poder.txt', 'r', encoding='utf-8')\n",
    "print(list(arq))\n",
    "arq.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('aneis_poder.txt', 'r', encoding='utf-8')\n",
    "print(arq.readlines())\n",
    "arq.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O método `arq.write(string)` escreve o conteúdo de string para o arquivo, retornando o número de caracteres escritos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('resultado.txt', 'w', encoding='utf-8')\n",
    "print(arq.write('É um teste\\n!'))\n",
    "arq.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outros tipos de objetos precisam ser convertidos – seja para uma string (em modo texto) ou para bytes (em modo binário) – antes de escrevê-los."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('resultado.txt', 'w', encoding='utf-8')\n",
    "tupla = ('a resposta da vida', 42)\n",
    "print(arq.write(str(tupla)))\n",
    "arq.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O método `arq.tell()` retorna um inteiro dando a posição atual do objeto arquivo, no arquivo representado, como número de bytes desde o início do arquivo, no modo binário, e um número ininteligível, quando no modo de texto."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para mudar a posição, use `arq.seek(offset, onde)`. A nova posição é computada pela soma do deslocamento `offset` a um ponto de referência especificado pelo argumento `onde`. Se o valor de `onde` é 0,a referência é o início do arquivo, 1 refere-se à posição atual, e 2 refere-se ao fim do arquivo. Este argumento pode ser omitido e o valor padrão é 0, usando o início do arquivo como referência."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arq = open('resultado.txt', 'rb+')\n",
    "print(arq.write(b'0123456789abcdef'))\n",
    "print(arq.seek(5)) # vai para o sexto byte no arquivo\n",
    "print(arq.seek(1))\n",
    "print(arq.seek(-3,2)) # vai para o terceiro byte no antes do fim\n",
    "print(arq.read(1))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em arquivos texto (abertos sem um `b`, em modo string), somente `seeks` relativos ao início do arquivo serão permitidos (exceto se for indicado o final do arquivo, com `seek(0, 2)`) e o único valor válido para `offset` são aqueles retornados por chamada à `arq.tell()`, ou zero. Qualquer outro valor para `offset` produz um comportamento indefinido.\n",
    "\n",
    "Objetos arquivo tem alguns método adicionais, como `isatty()` e `truncate()` que não são usados com frequência; consulte a Biblioteca de Referência para um guia completo de objetos arquivo."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.11.1"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "68f6cf9ddf20b8330c35f9eb8d38bef7105e3b161f09b6b7e5f8b2d3944d5325"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}