27. Lendo e Escrevendo em Arquivos

Até agora, todos os dados nos nossos programas foram temporários — armazenados em variáveis que desaparecem quando o programa termina. Para criar programas que lembram informações entre execuções, precisamos trabalhar com arquivos. Arquivos nos permitem salvar dados no disco e lê-los novamente depois, possibilitando desde configurações até armazenamento de dados do usuário.

Neste capítulo, você vai aprender como ler e escrever em arquivos de texto em Python. Vamos começar entendendo caminhos de arquivos e como o Python localiza arquivos, depois avançar por abrir, ler, escrever e fechar arquivos corretamente. Você vai aprender sobre diferentes modos de arquivo, encoding de texto e como lidar com erros comuns que acontecem durante operações com arquivos.

27.1) Caminhos de Arquivo e o Diretório de Trabalho Atual

Antes de podermos trabalhar com arquivos, precisamos entender como o Python os localiza no sistema de arquivos do seu computador.

27.1.1) Entendendo Caminhos de Arquivo

Um caminho de arquivo (file path) é o endereço de um arquivo no seu computador. Ele diz ao Python exatamente onde encontrar um arquivo. Existem dois tipos de caminhos:

Caminhos absolutos (absolute paths) especificam a localização completa a partir da raiz do sistema de arquivos:

• Windows: C:\Users\Alice\Documents\data.txt
• macOS/Linux: /home/alice/documents/data.txt

Caminhos relativos (relative paths) especificam uma localização relativa ao diretório de trabalho atual:

• data.txt (arquivo no diretório atual)
• reports/sales.txt (arquivo em um subdiretório)
• ../config.txt (arquivo no diretório pai)

O diretório de trabalho atual (current working directory, CWD) é a pasta onde o Python procura arquivos quando você usa caminhos relativos. Quando você executa um script Python, o CWD é o diretório a partir do qual você executou o comando, não necessariamente onde o arquivo do script está localizado.

Por exemplo:

# Directory structure:
/home/alice/
  └── projects/
      └── script.py
 
# Running from the projects folder:
$ cd /home/alice/projects
$ python script.py
# CWD is /home/alice/projects
 
# Running from the parent folder:
$ cd /home/alice
$ python projects/script.py
# CWD is /home/alice (not where script.py is!)

Você pode verificar o diretório de trabalho atual com:

import os
 
# Obter o diretório de trabalho atual
current_dir = os.getcwd()
print(f"Current directory: {current_dir}")

Output:

Current directory: /home/alice/projects/file_demo

A função os.getcwd() retorna o caminho absoluto do diretório de trabalho atual. Isso é útil para entender onde o Python vai procurar arquivos quando você usa caminhos relativos.

Entender o diretório de trabalho atual é importante porque ele determina onde o Python vai procurar quando você usa um caminho relativo como "data.txt". Se você executar seu script a partir de /home/alice/projects/ e abrir "data.txt", o Python procura por /home/alice/projects/data.txt.

27.1.2) Usando Caminhos Relativos de Forma Eficiente

Ao trabalhar com arquivos, caminhos relativos costumam ser mais convenientes do que caminhos absolutos porque tornam seu código portátil — ele funciona independentemente de onde a pasta do projeto está localizada em computadores diferentes.

Aqui estão padrões comuns de caminhos relativos:

# Arquivo no diretório de trabalho atual
filename = "student_grades.txt"
 
# Arquivo em um subdiretório (pasta data dentro do diretório atual)
filename = "data/student_grades.txt"
 
# Arquivo no diretório pai
filename = "../shared_data.txt"

Para os exemplos deste capítulo, vamos usar principalmente nomes simples como "data.txt". Isso significa:

• Os arquivos de dados devem estar no mesmo diretório onde você executa o comando Python
• Se seu script estiver em /home/alice/projects/ e você executar python script.py a partir desse diretório, o Python vai procurar data.txt em /home/alice/projects/

Essa abordagem mantém os exemplos claros e focados em operações com arquivos em vez de navegação por caminhos. Se você receber um FileNotFoundError, use os.getcwd() para verificar onde o Python está procurando arquivos.

27.1.3) Separadores de Caminho Entre Sistemas Operacionais

Sistemas operacionais diferentes usam caracteres diferentes para separar diretórios em caminhos:

• Windows usa barras invertidas: data\reports\sales.txt
• macOS e Linux usam barras normais: data/reports/sales.txt

O Python lida com isso automaticamente quando você usa barras normais no seu código — elas funcionam em todos os sistemas operacionais:

# Isso funciona no Windows, macOS e Linux
filename = "data/reports/sales.txt"

O Python converte as barras normais para o separador apropriado do seu sistema operacional.

27.2) Abrindo e Fechando Arquivos

Para trabalhar com um arquivo, primeiro precisamos abri-lo (open), o que cria uma conexão entre nosso programa e o arquivo no disco. Quando terminamos, precisamos fechá-lo (close) para liberar recursos do sistema e garantir que todos os dados sejam salvos corretamente.

27.2.1) A Função open()

A função open() cria um objeto arquivo (file object) que representa a conexão com um arquivo. Na forma mais simples, você fornece o nome do arquivo:

# Abrir um arquivo para leitura (o modo padrão)
file = open("message.txt")

Isso abre o arquivo message.txt no diretório atual. A função open() retorna um objeto arquivo, que armazenamos na variável file. Esse objeto fornece métodos para ler do arquivo ou escrever no arquivo.

No entanto, essa abordagem básica tem um problema crítico: se ocorrer um erro após abrir o arquivo, o arquivo talvez nunca seja fechado. Vamos ver por que fechar arquivos importa.

27.2.2) Por Que Fechar Arquivos É Importante

Quando você abre um arquivo, o sistema operacional aloca recursos para manter essa conexão. Se você não fechar o arquivo:

• Os dados podem não ser salvos: ao escrever em arquivos, os dados geralmente ficam em buffer na memória e só são gravados no disco quando o arquivo é fechado
• Recursos do sistema são desperdiçados: cada arquivo aberto consome memória e descritores de arquivo
• Outros programas podem ser bloqueados: alguns sistemas impedem que outros programas acessem um arquivo que já está aberto

Para fechar um arquivo, chame o método close() dele:

file = open("message.txt")
# ... trabalhar com o arquivo ...
file.close()  # Liberar recursos e garantir que os dados sejam salvos

27.2.3) O Problema do Fechamento Manual

Fechar arquivos manualmente é propenso a erros. Se uma exceção acontecer entre abrir e fechar, a chamada a close() pode nunca ser executada:

file = open("data.txt")
result = process_data(file)  # Se isso levantar uma exceção...
file.close()  # ...isso nunca roda!

Esse é um problema tão comum que o Python fornece uma solução melhor: a instrução with, que vamos aprender na Seção 27.4. Por enquanto, entenda que abrir e fechar arquivos manualmente exige atenção cuidadosa para garantir que close() sempre seja chamado.

27.2.4) Verificando Se um Arquivo Está Aberto

Um objeto arquivo tem um atributo closed que informa se o arquivo está fechado:

file = open("data.txt")
print(file.closed)  # Output: False
 
file.close()
print(file.closed)  # Output: True

Depois que um arquivo é fechado, tentar ler ou escrever nele vai levantar um erro:

file = open("data.txt")
file.close()
 
# Isso levanta ValueError: I/O operation on closed file
content = file.read()

A mensagem de erro indica claramente o problema: você está tentando executar uma operação de I/O (input/output) em um arquivo que já está fechado.

27.3) Entendendo Modos de Arquivo (r, w, a, texto vs binário) e Encoding

Ao abrir um arquivo, você pode especificar um modo (mode) que determina quais operações são permitidas e como o arquivo é tratado. Entender modos é crucial para trabalhar com arquivos corretamente.

27.3.1) Modo Texto vs Modo Binário

Arquivos podem ser abertos em dois modos fundamentais:

Modo texto (text mode) (o padrão) trata o arquivo como contendo texto. O Python automaticamente:

• Converte finais de linha para \n independentemente da plataforma
• Lida com encoding de texto (convertendo entre bytes e strings)
• Permite ler e escrever strings

Modo binário (binary mode) trata o arquivo como bytes brutos. O Python:

• Lê e escreve objetos bytes, não strings
• Não faz conversões nem interpretações
• É usado para imagens, áudio, vídeo e outros arquivos não textuais

Para este capítulo, vamos focar no modo texto, que é o que você vai usar com mais frequência. O modo binário é indicado adicionando 'b' à string de modo (como 'rb' ou 'wb'), mas não vamos precisar dele para arquivos de texto.

27.3.2) Os Três Modos Primários de Arquivo

O Python fornece três modos primários para abrir arquivos de texto:

Modo leitura ('r') - Abre um arquivo apenas para leitura:

file = open("data.txt", "r")  # or just open("data.txt")

• O arquivo já precisa existir, ou o Python levanta FileNotFoundError
• Você pode ler do arquivo, mas não pode escrever nele
• Esse é o modo padrão se você não especificar um

Modo escrita ('w') - Abre um arquivo para escrita:

file = open("output.txt", "w")

• Cria o arquivo se ele não existir
• Apaga todo o conteúdo existente se o arquivo já existir
• Você pode escrever no arquivo, mas não pode ler dele
• Use isso quando você quiser criar um arquivo novo ou substituir completamente um arquivo existente

Modo anexar ('a') - Abre um arquivo para anexar:

file = open("log.txt", "a")

• Cria o arquivo se ele não existir
• Preserva o conteúdo existente e adiciona conteúdo novo no final
• Você pode escrever no arquivo, mas não pode ler dele
• Use isso quando você quiser adicionar a um arquivo existente sem perder o conteúdo atual

Aqui vai uma comparação de como esses modos afetam um arquivo existente:

# Suponha que data.txt contenha: "Hello\nWorld\n"
 
# Modo leitura - conteúdo inalterado
file = open("data.txt", "r")
file.close()
# O arquivo ainda contém: "Hello\nWorld\n"
 
# Modo escrita - conteúdo apagado
file = open("data.txt", "w")
file.write("New content\n")
file.close()
# O arquivo agora contém: "New content\n"
 
# Modo anexar - conteúdo preservado, novo conteúdo adicionado
file = open("data.txt", "a")
file.write("Added line\n")
file.close()
# O arquivo agora contém: "New content\nAdded line\n"

27.3.3) Entendendo Encoding de Texto

Quando você trabalha com arquivos de texto, o Python precisa saber como converter entre os bytes armazenados no disco e os caracteres da string no seu programa. Esse processo de conversão é chamado de encoding (encoding).

O encoding mais comum é UTF-8, que pode representar qualquer caractere de qualquer idioma. É o encoding padrão no Python 3 e o padrão para arquivos de texto modernos.

# Especificar explicitamente o encoding UTF-8 (embora normalmente seja o padrão)
file = open("data.txt", "r", encoding="utf-8")

Por que encoding importa? Considere este arquivo de texto contendo um nome com um caractere acentuado:

# Escrevendo um arquivo com caracteres especiais
file = open("names.txt", "w", encoding="utf-8")
file.write("José\n")
file.write("François\n")
file.write("Müller\n")
file.close()
 
# Lendo de volta
file = open("names.txt", "r", encoding="utf-8")
content = file.read()
file.close()
print(content)

Output:

José
François
Müller

Se você tentar abrir um arquivo com o encoding errado, pode ver caracteres corrompidos ou receber um erro. Sempre use UTF-8 para arquivos novos, a menos que você tenha um motivo específico para usar um encoding diferente.

27.3.4) Variações Adicionais de Modo

O Python fornece caracteres de modo adicionais que podem ser combinados com os modos primários:

Modos plus (plus modes) permitem tanto leitura quanto escrita:

• 'r+' - Ler e escrever (o arquivo deve existir)
• 'w+' - Escrever e ler (apaga conteúdo existente)
• 'a+' - Anexar e ler (preserva conteúdo existente)

Para iniciantes, é mais claro abrir um arquivo uma vez para leitura e separadamente para escrita em vez de usar modos plus. Vamos ficar com os modos simples ('r', 'w', 'a') neste capítulo.

27.4) Usando with para Gerenciar Arquivos Automaticamente

A instrução with fornece uma forma mais limpa e segura de trabalhar com arquivos. Ela fecha o arquivo automaticamente quando você termina, mesmo se ocorrer um erro.

27.4.1) A Sintaxe da Instrução with

Veja como usar with para abrir um arquivo:

with open("data.txt", "r") as file:
    content = file.read()
    print(content)
# O arquivo é fechado automaticamente aqui

A sintaxe tem várias partes:

• with - Palavra-chave que inicia o gerenciador de contexto
• open("data.txt", "r") - Abre o arquivo
• as file - Cria uma variável para referenciar o objeto arquivo
• : - Inicia o bloco indentado
• Bloco indentado - Código que trabalha com o arquivo
• Depois do bloco - O arquivo é fechado automaticamente

O principal benefício: o Python garante que o arquivo será fechado quando o bloco with termina, independentemente de como ele termina (normalmente, com um return, ou por causa de uma exceção).

27.4.2) Por Que with É Melhor do Que Fechamento Manual

Compare estas duas abordagens:

# Fechamento manual - arriscado
file = open("data.txt", "r")
content = file.read()
result = process(content)  # Se isso levantar uma exceção...
file.close()  # ...isso nunca roda
 
# Usando with - seguro
with open("data.txt", "r") as file:
    content = file.read()
    result = process(content)  # Mesmo se isso levantar uma exceção...
# ...o arquivo ainda é fechado automaticamente

A instrução with usa o protocolo de gerenciador de contexto (context manager protocol) do Python (que vamos explorar em detalhes no Capítulo 28). Por enquanto, pense nisso como uma garantia: "Vou limpar esse recurso quando você terminar, não importa o que aconteça."

27.4.3) Trabalhando com Vários Arquivos

Você pode abrir vários arquivos em uma única instrução with:

with open("input.txt", "r") as infile, open("output.txt", "w") as outfile:
    content = infile.read()
    outfile.write(content.upper())
# Ambos os arquivos são fechados automaticamente aqui

Isso é útil quando você precisa ler de um arquivo e escrever em outro simultaneamente. Ambos os arquivos têm garantia de serem fechados corretamente, mesmo se ocorrer um erro.

27.4.4) O Objeto Arquivo Só É Válido Dentro do Bloco with

Assim que o bloco with termina, o arquivo é fechado e você não pode mais usar o objeto arquivo:

with open("data.txt", "r") as file:
    content = file.read()
    print("Inside with block:", file.closed)  # Output: Inside with block: False
 
print("Outside with block:", file.closed)  # Output: Outside with block: True
 
# This raises ValueError: I/O operation on closed file
more_content = file.read()

Esse comportamento é intencional — ele evita que você use acidentalmente um arquivo fechado. Se você precisar do conteúdo do arquivo fora do bloco with, armazene-o em uma variável (como content acima) antes que o bloco termine.

A partir deste ponto do capítulo, vamos usar with para todas as operações com arquivos. É a abordagem recomendada e o que você deve usar no seu próprio código.

27.5) Lendo Arquivos de Texto

Agora que entendemos como abrir arquivos com segurança usando with, vamos explorar as diferentes maneiras de ler conteúdo de arquivos de texto.

27.5.1) Lendo o Arquivo Inteiro com read()

O método read() lê todo o conteúdo do arquivo como uma única string:

with open("message.txt", "r") as file:
    content = file.read()
    print(content)

Se message.txt contém:

Welcome to Python!
This is a text file.
It has multiple lines.

Output:

Welcome to Python!
This is a text file.
It has multiple lines.

O método read() inclui todos os caracteres de nova linha (\n) do arquivo. Quando você imprime a string, o Python exibe cada linha em uma linha separada por causa desses caracteres de nova linha.

Você também pode ler um número específico de caracteres passando um número para read():

with open("message.txt", "r") as file:
    first_ten = file.read(10)  # Ler os primeiros 10 caracteres
    print(f"First 10 characters: '{first_ten}'")

Output:

First 10 characters: 'Welcome to'

Ler o arquivo inteiro é simples e funciona bem para arquivos pequenos. No entanto, para arquivos grandes (megabytes ou gigabytes), ler tudo de uma vez pode consumir memória demais. Nesses casos, ler linha por linha é mais eficiente.

27.5.2) Lendo Linha por Linha com readline()

O método readline() lê uma única linha do arquivo, incluindo o caractere de nova linha no final:

with open("message.txt", "r") as file:
    line1 = file.readline()
    line2 = file.readline()
    line3 = file.readline()
    print(f"Line 1: {line1}")
    print(f"Line 2: {line2}")
    print(f"Line 3: {line3}")

Output:

Line 1: Welcome to Python!
 
Line 2: This is a text file.
 
Line 3: It has multiple lines.
 

Repare nas linhas em branco extras no output. Cada linha lida do arquivo termina com \n, e o print() adiciona outra nova linha. Para evitar isso, use o método rstrip() para remover espaços em branco no final:

with open("message.txt", "r") as file:
    line1 = file.readline().rstrip()
    line2 = file.readline().rstrip()
    print(f"Line 1: {line1}")
    print(f"Line 2: {line2}")

Output:

Line 1: Welcome to Python!
Line 2: This is a text file.

Quando readline() chega ao final do arquivo, ele retorna uma string vazia "". Isso permite detectar quando não há mais linhas para ler:

with open("message.txt", "r") as file:
    while True:
        line = file.readline()
        if line == "":  # Fim do arquivo
            break
        print(line.rstrip())

No entanto, existe uma forma mais Pythonic de ler arquivos linha por linha.

27.5.3) Iterando Pelas Linhas com um loop for

Objetos arquivo são iteráveis (iterable), o que significa que você pode fazer loop diretamente neles com um loop for. Essa é a forma mais comum e Pythonic de ler um arquivo linha por linha:

with open("message.txt", "r") as file:
    for line in file:
        print(line.rstrip())

Output:

Welcome to Python!
This is a text file.
It has multiple lines.

Essa abordagem é:

• Mais limpa: não precisa de readline() nem de checar strings vazias
• Mais eficiente: o Python lê o arquivo em blocos, sem carregar o arquivo inteiro na memória
• Mais Pythonic: usa iteração, que é um conceito central do Python

Cada iteração do loop lê a próxima linha do arquivo. Quando não há mais linhas, o loop termina automaticamente.

27.5.4) Lendo Todas as Linhas em uma Lista com readlines()

O método readlines() lê todas as linhas do arquivo e as retorna como uma lista(list) de strings:

with open("message.txt", "r") as file:
    lines = file.readlines()
 
print(f"Number of lines: {len(lines)}")
for i, line in enumerate(lines, start=1):
    print(f"Line {i}: {line.rstrip()}")

Output:

Number of lines: 3
Line 1: Welcome to Python!
Line 2: This is a text file.
Line 3: It has multiple lines.

Cada elemento na lista é uma string contendo uma linha do arquivo, incluindo seu caractere de nova linha. Isso é útil quando você precisa:

• Acessar linhas por índice: lines[0], lines[1], etc.
• Processar linhas várias vezes
• Saber o número total de linhas antes de processar

No entanto, assim como read(), readlines() carrega o arquivo inteiro na memória. Para arquivos grandes, iterar com um loop for é mais eficiente em memória.

27.6) Escrevendo e Anexando em Arquivos de Texto

Escrever em arquivos é tão importante quanto ler. O Python fornece métodos simples para criar arquivos novos ou modificar arquivos existentes.

27.6.1) Escrevendo em um Arquivo com write()

Para escrever em um arquivo, abra-o no modo escrita ('w') e use o método write():

with open("output.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new file.\n")

Depois de executar este código, output.txt contém:

Hello, World!
This is a new file.

Pontos importantes sobre write():

• Ele escreve uma string no arquivo
• Ele não adiciona automaticamente caracteres de nova linha — você deve incluir \n por conta própria
• Ele retorna o número de caracteres escritos (embora geralmente ignoremos isso)
• Se o arquivo já existir, o modo escrita apaga todo o conteúdo existente antes de escrever

Vamos ver o que acontece quando escrevemos em um arquivo existente:

# Primeiro, criar um arquivo com algum conteúdo
with open("demo.txt", "w") as file:
    file.write("Original content\n")
 
# Agora abri-lo de novo em modo escrita
with open("demo.txt", "w") as file:
    file.write("New content\n")
 
# Ler o arquivo para ver o que ele contém
with open("demo.txt", "r") as file:
    print(file.read())

Output:

New content

O conteúdo original se foi. O modo escrita sempre começa com um arquivo vazio, seja criando um arquivo novo ou sobrescrevendo um existente.

27.6.2) Escrevendo Várias Linhas

Você pode chamar write() várias vezes para escrever várias linhas:

with open("shopping_list.txt", "w") as file:
    file.write("Apples\n")
    file.write("Bananas\n")
    file.write("Oranges\n")

27.6.3) Escrevendo Dados a partir de Coleções

Uma tarefa comum é escrever dados de listas ou outras coleções em um arquivo:

students = ["Alice", "Bob", "Carol", "David"]
 
with open("students.txt", "w") as file:
    for student in students:
        file.write(student + "\n")

Isso cria students.txt contendo:

Alice
Bob
Carol
David

27.6.4) Anexando em um Arquivo

Quando você quer adicionar conteúdo ao final de um arquivo existente sem apagar o que já está lá, use o modo anexar ('a'):

# Criar um arquivo com conteúdo inicial
with open("log.txt", "w") as file:
    file.write("Program started\n")
 
# Depois, anexar mais conteúdo
with open("log.txt", "a") as file:
    file.write("Processing data\n")
    file.write("Processing complete\n")
 
# Ler o arquivo para ver todo o conteúdo
with open("log.txt", "r") as file:
    print(file.read())

Output:

Program started
Processing data
Processing complete

O modo anexar é perfeito para arquivos de log, onde você quer manter um registro contínuo de eventos. Cada vez que você abre o arquivo no modo anexar, o novo conteúdo é adicionado ao final, preservando tudo o que já estava lá.

27.7) Lidando com Erros Comuns de I/O de Arquivos

Operações com arquivos podem falhar por vários motivos: o arquivo não existe, você não tem permissão para acessá-lo, o disco está cheio ou o arquivo já está aberto por outro programa. Aprender a lidar com esses erros de forma elegante torna seus programas mais robustos e fáceis de usar.

27.7.1) FileNotFoundError: Quando um Arquivo Não Existe

O erro de arquivo mais comum acontece quando você tenta ler um arquivo que não existe:

# AVISO: Isso vai levantar FileNotFoundError se data.txt não existir
with open("data.txt", "r") as file:
    content = file.read()

Se data.txt não existir, o Python levanta:

FileNotFoundError: [Errno 2] No such file or directory: 'data.txt'

Para lidar com isso de forma elegante, use um bloco try-except (como aprendemos no Capítulo 25):

try:
    with open("data.txt", "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("Error: The file 'data.txt' was not found.")
    print("Please check the filename and try again.")

Output (se o arquivo não existir):

Error: The file 'data.txt' was not found.
Please check the filename and try again.

Essa abordagem evita que seu programa quebre e fornece uma mensagem útil para o usuário.

27.7.2) PermissionError: Quando Você Não Consegue Acessar um Arquivo

Às vezes você não tem permissão para ler ou escrever um arquivo:

try:
    with open("/root/protected.txt", "r") as file:
        content = file.read()
except PermissionError:
    print("Error: You don't have permission to access this file.")

Erros de permissão podem acontecer quando:

• O arquivo pertence a outro usuário
• O arquivo está em um diretório de sistema protegido
• O arquivo está marcado como somente leitura e você está tentando escrever nele
• No Windows, o arquivo está aberto em outro programa

27.7.3) IsADirectoryError: Quando Você Tenta Abrir um Diretório

Se você acidentalmente tentar abrir um diretório em vez de um arquivo:

try:
    with open("my_folder", "r") as file:
        content = file.read()
except IsADirectoryError:
    print("Error: 'my_folder' is a directory, not a file.")

Isso pode acontecer quando você tem tanto um arquivo quanto um diretório com nomes parecidos, ou quando você esquece de incluir o nome do arquivo em um caminho.

27.7.4) UnicodeDecodeError: Quando o Encoding Não Bate

Se você tentar ler um arquivo com o encoding errado, pode obter um UnicodeDecodeError:

try:
    with open("data.txt", "r", encoding="utf-8") as file:
        content = file.read()
except UnicodeDecodeError:
    print("Error: The file encoding doesn't match UTF-8.")
    print("The file might use a different encoding.")

Esse erro acontece quando o arquivo contém bytes que não são UTF-8 válidos. Se você encontrar isso, o arquivo pode estar:

• Usando um encoding diferente (como Latin-1 ou Windows-1252)
• Sendo um arquivo binário que você está tentando ler como texto
• Corrompido

27.7.5) Lidando com Vários Tipos de Erro

Você pode capturar vários tipos de erro em um único bloco try-except:

filename = input("Enter filename: ")
 
try:
    with open(filename, "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print(f"Error: '{filename}' does not exist.")
except PermissionError:
    print(f"Error: You don't have permission to read '{filename}'.")
except IsADirectoryError:
    print(f"Error: '{filename}' is a directory, not a file.")
except UnicodeDecodeError:
    print(f"Error: '{filename}' contains invalid text encoding.")

Isso fornece mensagens de erro específicas e úteis para cada tipo de problema. O usuário sabe exatamente o que deu errado e pode tomar a ação apropriada.

27.7.6) Usando um Manipulador de Exceção Genérico

Às vezes você quer capturar qualquer erro inesperado relacionado a arquivos além dos tipos específicos que cobrimos. Você pode usar um manipulador geral de Exception como um catch-all após seus manipuladores específicos:

filename = input("Enter filename: ")
 
try:
    with open(filename, "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print(f"Error: '{filename}' not found.")
except PermissionError:
    print(f"Error: No permission to read '{filename}'.")
except IsADirectoryError:
    print(f"Error: '{filename}' is a directory.")
except UnicodeDecodeError:
    print(f"Error: '{filename}' has invalid encoding.")
except Exception as e:
    print(f"Unexpected error reading file: {e}")

Isso garante que seu programa lide até mesmo com erros que você não antecipou. A variável e contém o objeto de exceção, que inclui uma mensagem de erro descritiva. Imprimi-la dá ao usuário detalhes técnicos sobre o que deu errado.

Trabalhar com arquivos é uma habilidade fundamental em programação. Você aprendeu a:

• Entender caminhos de arquivo e o diretório de trabalho atual
• Abrir e fechar arquivos corretamente
• Usar diferentes modos de arquivo para leitura, escrita e anexação
• Gerenciar arquivos automaticamente com a instrução with
• Ler arquivos usando vários métodos (read(), readline(), iteração, readlines())
• Escrever e anexar conteúdo em arquivos
• Lidar com erros comuns de I/O de arquivos de forma elegante

Essas habilidades permitem criar programas que persistem dados entre execuções, processam arquivos de texto, geram relatórios e muito mais. No próximo capítulo, vamos explorar gerenciadores de contexto em profundidade, entendendo o mecanismo que faz a instrução with funcionar e como criar seus próprios gerenciadores de contexto para gerenciar recursos além de arquivos.