O melhor do porno: uma puta gostosa dando um sexo anal
Prepare-se para assistir a uma verdadeira obra-prima do pornô, onde uma deliciosa novinha vai te fazer perder o fôlego com suas curvas irresistíveis. Ela está ansiosa para ser devorada por um macho que sabe exactly onde tocar para deixar a pequena gostosa implorando por mais.
Novinha Gostosa Se Esfregando em uma Roça Gigante
Essa safada não perde tempo e logo está se contorcendo de prazer enquanto o parceiro explor
+++++ content/pt-br/docs/pt-br/pt-br/pt-br/pt-br/python/python/manipulando-arquivos.md
—
title: Manipulando Arquivos
linktitle: Manipulando Arquivos
date: 2019-04-12T13:00:00Z
lastmod: 2022-10-11T19:25:51Z
draft: false
images: []
menu:
pt-br:
parent: “python”
weight: 50
toc: true
—
{{% pageinfo color=”warning” %}}
Este material foi traduzido automaticamente.
{{% /pageinfo %}}
## Introdução
Um arquivo é um objeto contendo um fluxo de dados. O módulo `io` fornece classes para manipuladores de arquivos e fluxos de dados, como StringIO, BytesIO e alguns outros. Arquivos são usados para leitura e escrita de fluxos de dados. [Os módulos `os` e `pathlib` dão suporte à manipulação de caminhos e diretórios de arquivos.](#os-and-pathlib) [O módulo `shutil` é usado para a manipulação de arquivos e operações de cópia.](#shutil)
## Leitura e Escrita
O módulo `io` fornece classes para manipuladores de arquivos e fluxos de dados, como StringIO, BytesIO e alguns outros. Arquivos são usados para leitura e escrita de fluxos de dados. [Os módulos `os` e `pathlib` dão suporte à manipulação de caminhos e diretórios de arquivos.](#os-and-pathlib) [O módulo `shutil` é usado para a manipulação de arquivos e operações de cópia.](#shutil)
## `open` é um construtor
A função `open` é uma factories que constrói objetos de fluxo de dados. Esses objetos são chamados de manipuladores de arquivos. O construtor `open` tem a seguinte assinatura:
“`
open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
“`
Se você quiser ser explícito, é possível instanciar `io.TextIOWrapper` ou `io.BytesIO` usando os argumentos apropriados:
“`python
import io
f = io.TextIOWrapper(io.BytesIO(b’foo’), encoding=’utf-8′)
print(f.read())
“`
## Maneiras de abrir um arquivo
A seguir estão as diferentes maneiras de abrir um arquivo. A função `open` sempre retorna um objeto de fluxo de dados, que pode ser um `io.TextIOWrapper` ou `io.BytesIO`.
### Modo de texto
“`python
f = open(‘foo.txt’, ‘rt’) # r = read, t = text
“`
### Modo binário
“`python
f = open(‘foo.txt’, ‘rb’) # r = read, b = binary
“`
### Modo de texto com encoding
“`python
f = open(‘foo.txt’, ‘r’, encoding=’utf-8′)
“`
### Modo binário com encoding
“`python
f = open(‘foo.txt’, ‘rb’)
“`
## Modos de abertura
O segundo argumento é o modo de abertura, que define a operação permitida. Ele pode ser um dos seguintes valores:
| Modo | Descrição |
| — | — |
| `r` | Abra para leitura (padrão) |
| `w` | Abra para escrita, truncando o arquivo se ele existir |
| `x` | Abra para escrita exclusiva, criando o arquivo se ele não existir |
| `a` | Abra para escrita, mantendo o conteúdo atual do arquivo |
| `+` | Abra para atualização (leitura e escrita) |
| `U` | Abra em modo universal (dará suporte a fluxos de texto em ambos os sistemas de arquivos Windows e Unix) |
| `b` | Abra em modo binário (padrão) |
## Atributos
Um manipulador de arquivo tem vários atributos. Os mais úteis são:
### `f.closed`
Retorna `True` se o fluxo de dados estiver fechado, `False` caso contrário. O fluxo de dados é fechado automaticamente quando todos os manipuladores de fluxo de dados são fechados.
### `f.mode`
Retorna o modo de abertura do fluxo de dados.
### `f.name`
Retorna o nome do arquivo.
## Métodos
As seguintes seções mostram os métodos mais importantes em um objeto de fluxo de dados.
### `f.close()`
Fecha o fluxo de dados.
### `f.flush()`
Escreve qualquer dado não enviado no buffer para o arquivo. Este método é opcional.
### `f.fileno()`
Retorna o descritor de arquivo do fluxo de dados para o sistema. É útil quando você precisa do descritor de arquivo para fazer chamadas do sistema.
### `f.isatty()`
Verifica se o fluxo de dados é um terminal. Um terminal é qualquer fluxo de dados que você pode interagir, como um teclado ou uma janela de terminal.
### `f.readline([size])`
Lê e retorna um único linha a partir do fluxo de dados. Se o tamanho não for especificado, lê até o final do arquivo. Se o fluxo de dados estiver no final, retorna uma string vazia.
“`python
f = open(‘foo.txt’, ‘rt’)
print(f.readline()) # imprimi: foo
“`
### `f.read([size])`
Lê e retorna `size` bytes/bytes a partir do fluxo de dados. Se `size` não for especificado, lê até o final do arquivo.
“`python
f = open(‘foo.txt’, ‘rt’)
print(f.read()) # imprimi: foonbarnbaz
“`
### `f.readlines([size])`
Lê e retorna uma lista de linhas a partir do fluxo de dados. Se o `size` não for especificado, lê até o final do arquivo.
### `f.seek(offset[, whence])`
Muda a posição atual do fluxo de dados. O `offset` é o número de bytes para se mover em relação ao `whence`. O `whence` é um dos seguintes valores:
| whence | Descrição |
| — | — |
| `0` | Comece a busca no início do fluxo de dados (padrão). |
| `1` | Comece a busca na posição atual do fluxo de dados. |
| `2` | Comece a busca no final do fluxo de dados. |
### `f.tell()`
Retorna a posição atual do fluxo de dados.
### `f.truncate([size])`
Trunca o fluxo de dados para `size` bytes. Se `size` não for especificado, o fluxo de dados será truncado para zero bytes.
### `f.write(string)`
Escreve uma string no fluxo de dados e retorna o número de bytes escritos. A string é escrita sem a quebra de linha.
### `f.writelines(sequence)`
Escreve uma sequência de linhas no fluxo de dados. A sequencia deve ser uma sequência de strings, cada string é escrita sem a quebra de linha.
“`python
f = open(‘foo.txt’, ‘wt’)
f.writelines([‘foon’, ‘barn’, ‘bazn’])
“`
### `f.__enter__()`
Retorna o fluxo de dados. Este é o método que é chamado quando um contexto é usado. Um contexto é um bloco de código que é executado automaticamente ao abrir um fluxo de dados e fechar automaticamente quando o fluxo de dados for fechado.
“`python
with open(‘foo.txt’, ‘rt’) as f:
print(f.read())
“`
## `with` statements
O statement `with` é um bloco de código que é executado automaticamente quando o fluxo de dados for aberto e fechado automaticamente quando o fluxo de dados for fechado. Isso pode ser útil quando você precisa de um fluxo de dados que não pode ser fechado explicitamente, como um fluxo de dados de rede.
“`python
with open(‘foo.txt’, ‘rt’) as f:
print(f.read())
“`
O fluxo de dados é automaticamente fechado depois de executar o bloco de código.
## `os` e `pathlib`
{{% pageinfo %}}
Esta seção foi movida para [os e pathlib](/pt-br/os-e-pathlib/).
{{% /pageinfo %}}
## `shutil`
{{% pageinfo %}}
Esta seção foi movida para [shutil](/pt-br/shutil/).
{{% /pageinfo %}}
O melhor do porno: uma puta gostosa dando um sexo anal
