Programação e script

Como executar operações de entrada/saída Python em arquivos com função aberta do Python

Como executar operações de entrada/saída Python em arquivos com função aberta do Python

A manipulação de arquivos é uma operação que mais cedo ou mais tarde precisaremos executar em nossos programas. O python embutido abrir Função retorna a objeto de arquivo, que nos permite interagir com arquivos em diferentes modos: nós os veremos neste artigo.

Neste tutorial em Python, você aprenderá:

  • Como usar a função aberta do Python.
  • Quais são os vários modos de operação que podem ser usados ​​com a função aberta do Python.
  • Como interagir com um objeto de arquivo.
  • Por que é importante fechar um objeto de arquivo e como fazê -lo.

Requisitos de software e convenções usadas

Requisitos de software e convenções de linha de comando Linux
Categoria Requisitos, convenções ou versão de software usada
Sistema Independente do OS
Programas Python3
Outro Nenhuma permissões especiais necessárias.
Convenções # - requer que os comandos Linux sejam executados com privilégios root diretamente como usuário root ou por uso de sudo comando
$ - Requer que os comandos do Linux sejam executados como um usuário não privilegiado regular
>>> - comandos python a serem executados em uma concha interativa

Declarações de entrada e saída Python

Há muitas razões pelas quais um programa pode precisar interagir com arquivos: leitura de configurações e configurações que influenciarão o comportamento do próprio programa, ou talvez dados persistentes. Neste tutorial, veremos como realizar essas tarefas, usando a função aberta do Python e interagindo com objetos de arquivo.

A função aberta do Python

Antes de começar a ler ou escrever arquivos, precisamos aprender como podemos acessá -los. A função aberta do Python abre um arquivo e retorna um objeto de arquivo, levantando um OSERROR exceção se o recurso não puder ser acessado. A função tem apenas um argumento obrigatório, arquivo, que é a string ou objeto de byte que representa o caminho do arquivo a ser aberto:

>>> fobject = Open ('LinuxConfig.TXT')
cópia de

Modo de leitura - 'r'

Nós abrimos o LinuxConfig.TXT arquivo e o objeto de arquivo resultante agora é referenciado por fobject. É um python Objeto de arquivo que implementa métodos como escrever e ler. E se o LinuxConfig.TXT arquivo não existia? A FILENOTFoundError Exceção seria levantada:

>>> fobject = Open ('LinuxConfig.txt ') traceback (chamada mais recente): arquivo "", linha 1, em  FILENOTFoundError: [Errno 2] Nenhum arquivo ou diretório: 'LinuxConfig.TXT'
cópia de

Como acabamos de dizer acima, o único argumento obrigatório da função aberta do Python é arquivo. Quando usado como no exemplo acima, a função opera em modo de texto e um arquivo é aberto apenas para leitura. O equivalente detalhado do que fizemos acima é:

>>> fobject = Open ('LinuxConfig.txt ',' rt ')
cópia de

O segundo argumento da função é o modo. Nesse caso, 'rt', onde o 'r' apoia ler e a 't' especifica que estamos operando no modo de texto. Também é possível abrir arquivos no modo binário, substituindo 't' com 'B': Nesse caso, o conteúdo de bytes, sem qualquer codificação, será devolvido. Desde 't' é o modo padrão, a partir de agora, vamos omitir. Para ler o conteúdo do arquivo que podemos usar, por exemplo, o ler método. Ele retornará todo o conteúdo do arquivo como uma string:

>>> fobject.leia () 'LinuxConfig é incrível!\ n '
cópia de

Quando está operando no modo de leitura, qualquer tentativa de escrever para o arquivo aumentará um io.Não suportado operação exceção:

>>> fobject.Write ('LinuxConfig é incrível!') Traceback (chamada mais recente): arquivo "", linha 1, em  io.Não suportado operador: não gravável
cópia de

Obviamente, este não é o único modo disponível. Vamos ver os outros.

Modo de gravação - 'W'

Ao especificar 'c' Como o valor do modo argumento do abrir função, se o arquivo existir, é o primeiro truncado (seu conteúdo inteiro é descartado) e depois é aberto para escrever; Se o arquivo não existir, é criado. Nesse caso, usamos o escrever Método do objeto de arquivo:

>>> fobject = Open ('LinuxConfig.txt ',' w ') >>> fobject.Write ('Acabamos de escrever no arquivo!') 26 >>> fobject.fechar()
cópia de

Abrimos o arquivo para escrever, do que usamos o escrever Método do objeto de arquivo, que escreve a string e retorna o número de caracteres escritos, 26 neste caso, finalmente usamos o fechar Método para fechar o objeto: esta etapa é realmente importante, uma vez que a operação de gravação se torna efetiva apenas quando o conteúdo do arquivo for liberado (veremos a importância de fechar um objeto de arquivo no final do tutorial). Se agora examinarmos o conteúdo do arquivo, vemos que seu conteúdo anterior foi substituído e ele contém apenas a string:

'Acabamos de escrever para o arquivo!'

Como aconteceu acima, se tentarmos executar uma operação não permitida pelo modo de operação, uma exceção é aumentada. Nesse caso, se tentarmos ler o conteúdo do arquivo, obtemos o seguinte resultado:

>>> fobject = Open ('LinuxConfig.txt ',' w ') >>> fobject.Leia () Traceback (Chamada mais recente): Arquivo "", linha 1, em IO.UnsupportDoperation: não é legível
cópia de

Anexando a um arquivo: 'a' modo

E se quisermos anexar um arquivo, mantendo seu conteúdo atual? Temos que usar o 'a' Modo (Apêndice). Quando esse modo é usado, se existir um arquivo, ele será aberto para escrever e o fluxo está posicionado no final. Dessa forma, o conteúdo anterior do arquivo será preservado. Se o arquivo não existir, ele será criado:

>>> fobject = Open ('LinuxConfig.txt ',' a ') >>> fobject.Write ('texto anexado!') 14 >>> fobject.fechar()
cópia de

Abrimos o arquivo em 'a' modo e escreva a string 'texto anexado' para o arquivo. O conteúdo anterior não foi truncado:

LinuxConfig é incrível! Texto anexado!

O modo 'x' - criação exclusiva

Este modo de abertura está disponível apenas no Python3. Quando é usado, um FileExistSerror é levantado se o arquivo já existir. Se o arquivo não existir, ele será criado e aberto para escrever:

fileObject = aberto ('LinuxConfig.txt ',' x ') traceback (chamada mais recente): arquivo "", linha 1, em  FileExistSerror: [Errno 17] Existe: 'LinuxConfig.TXT'
cópia de

Cada vez que escrevemos algo, ele é anexado ao conteúdo anterior, até fecharmos o objeto de arquivo:

>>> fileObject = aberto ('LinuxConfig1.txt ',' x ') >>> FileObject.Write ('LinuxConfig é incrível novamente \ n') >>> FileObject.Write ('Repito: LinuxConfig é incrível!\ n ') >>> FileObject.fechar()
cópia de

Depois de executar o código acima, o novo conteúdo do arquivo será:

LinuxConfig é incrível! Repito: LinuxConfig é incrível!

O personagem '+'

Vimos os modos básicos que podem ser usados ​​com o abrir função e como eles funcionam. Anexando o '+' personagem para cada um deles, podemos obter novos comportamentos.

O modo 'r+'

Ao anexar o caractere '+' ao modo 'r' ('r+'), um arquivo é aberto para leitura e escrita; Uma exceção é levantada se o arquivo não existir. O fluxo está posicionado no início do arquivo; portanto, se algo for escrito, ele substituirá o conteúdo anterior. Se estamos nesse modo, mas ainda assim queremos que o novo conteúdo seja anexado, reservando o existente, devemos alterar a posição atual usando o procurar Método do objeto de arquivo antes de escrever, da seguinte maneira:

>>> fileObject = aberto ('LinuxConfig.txt ',' r+'): >>> FileObject.procurar (0,2) >>> FileObject.Write ('Este texto será anexado') >>> FileObject.fechar()
cópia de

O procurar o método leva dois argumentos: o primeiro é o desvio, o segundo é a posição a partir da qual o deslocamento deve ser calculado, onde 0 (o padrão se esse argumento for omitido) é o começo do arquivo, 1 é o deslocamento atual e 2 é o fim do arquivo. Nesse caso, usamos um deslocamento de 0 do final do arquivo, mudando -se para o final do próprio arquivo. Observe que especificar um deslocamento diferente de zero neste caso teria aumentado um io.Não suportado operação Exceção, pois é impossível fazer uma busca diferente de zero e final.

O modo 'w+'

Este modo funciona da seguinte maneira: o arquivo será aberto para leitura e escrita. Se o arquivo existir, seu conteúdo será truncado, caso contrário, o arquivo será criado. Assim como o exemplo anterior, será possível ler e escrever o arquivo, no entanto, existem duas grandes diferenças: a primeira é que o conteúdo do arquivo será truncado assim que for aberto (e não se você ativo, escreva algo para é), o segundo é que o arquivo será criado se não existir.

O modo 'A+'

Ao especificar esse modo com a função aberta do Python, obtemos o seguinte comportamento: Assim como nos exemplos anteriores, o arquivo é aberto tanto para leitura quanto para escrever, no entanto, o fluxo está posicionado no final do arquivo, portanto, qualquer novo conteúdo é anexado ao existente.

Duas coisas devem ser observadas: como o fluxo está posicionado no final do arquivo, se tentarmos usar o ler Método no objeto de arquivo para obter o conteúdo atual, ele retornará uma string vazia. Para poder ler o conteúdo, devemos primeiro passar para o início do arquivo, usando o método de busca da seguinte maneira:

FileObject.procure (0)
cópia de

A segunda coisa muito importante a perceber é que, ao usar esse modo, mesmo se mudarmos para o início do arquivo, como fizemos no exemplo acima e executamos uma gravação, o conteúdo existente que não está perdido: o novo conteúdo está sempre anexado.

Fechando o objeto de arquivo

Depois de terminarmos de trabalhar com nosso objeto de arquivo, devemos sempre lembrar de fechá -lo, por vários motivos. No Primis, porque algumas operações, como escrever, tornam -se efetivas apenas quando o objeto de arquivo é fechado e seu conteúdo é liberado, secundariamente para os recursos livres do sistema e para a clareza do código. Existem duas maneiras de fechar um objeto de arquivo: o primeiro é chamando o fechar método no objeto de arquivo, como vimos acima. O segundo, é usando o com declaração:

com open ('LinuxConfig.txt ',' r ') como arquivo fileObject: content = FileObject.leia () # execute as operações necessárias
cópia de

O que acontece nesse caso? Usando esta afirmação, a expressão ao lado de com, nesse caso Open ('LinuxConfig.txt ',' r '), é avaliado em um objeto de arquivo, que suporta o protocolo de gerenciador de contexto, pois implementa o __digitar__ e __saída__ métodos. O objeto de arquivo é então alias para FileObject. Depois que o código contido no bloco é executado, o __saída__ o método do objeto de arquivo é chamado automaticamente e o objeto de arquivo está fechado. Usar um gerente de contexto é realmente útil, porque o objeto será sempre fechado assim que terminarmos de operar nele: uma coisa a menos a lembrar.

Conclusões

Neste tutorial, aprendemos a usar o python embutido abrir função para criar um objeto de arquivo, usado para interagir com um arquivo. Vimos os vários modos que podem ser passados ​​para a função e como eles mudam o comportamento do objeto de arquivo. Por fim, vimos por que é importante fechar sempre um objeto de arquivo depois de terminarmos de trabalhar com ele, como podemos fazê -lo usando o fechar método e como pode ser feito automaticamente, se usarmos o com declaração e um gerente de contexto. Como sempre sugerido, você pode consultar a documentação oficial para melhorar ainda mais seu conhecimento.

Veja também nosso tutorial mais extenso do Python para mais conceitos relacionados ao Python ou nossos arquivos de leitura e escrita com Python Guide.

Tutoriais do Linux relacionados:

  • Manipulando a entrada do usuário em scripts bash
  • Mastering Bash Script Loops
  • Arquivos de configuração do Linux: os 30 primeiros mais importantes
  • Manipulação de big data para diversão e lucro Parte 1
  • Manipulação de big data para diversão e lucro Parte 3
  • Uma introdução à automação, ferramentas e técnicas do Linux
  • Coisas para instalar no Ubuntu 20.04
  • Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
  • Manipulação de big data para diversão e lucro Parte 2
  • Como montar a imagem ISO no Linux