27. Чтение из файлов и запись в файлы

До сих пор все данные в наших программах были временными — хранились в переменных, которые исчезают, когда программа завершает работу. Чтобы создавать программы, которые запоминают информацию между запусками, нам нужно работать с файлами. Файлы позволяют сохранять данные на диск и читать их позже, обеспечивая всё — от настроек конфигурации до хранения пользовательских данных.

В этой главе вы узнаете, как читать и записывать текстовые файлы в Python. Мы начнём с понимания путей к файлам и того, как Python находит файлы, затем перейдём к открытию, чтению, записи и корректному закрытию файлов. Вы узнаете о разных режимах файлов, кодировке текста и о том, как обрабатывать распространённые ошибки, возникающие при файловых операациях.

27.1) Пути к файлам и текущий рабочий каталог

Прежде чем мы сможем работать с файлами, нужно понять, как Python находит их в файловой системе вашего компьютера.

27.1.1) Понимание путей к файлам

Путь к файлу — это адрес файла на вашем компьютере. Он сообщает Python, где именно найти файл. Существует два типа путей:

Абсолютные пути задают полное расположение от корня файловой системы:

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

Относительные пути задают расположение относительно текущего рабочего каталога:

• data.txt (файл в текущем каталоге)
• reports/sales.txt (файл в подкаталоге)
• ../config.txt (файл в родительском каталоге)

Текущий рабочий каталог (CWD) — это папка, где Python ищет файлы, когда вы используете относительные пути. Когда вы запускаете Python-скрипт, CWD — это каталог, из которого вы запустили команду, а не обязательно тот, где находится файл скрипта.

Например:

# 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!)

Вы можете проверить текущий рабочий каталог с помощью:

import os
 
# Получить текущий рабочий каталог
current_dir = os.getcwd()
print(f"Current directory: {current_dir}")

Output:

Current directory: /home/alice/projects/file_demo

Функция os.getcwd() возвращает абсолютный путь текущего рабочего каталога. Это полезно для понимания того, где Python будет искать файлы, когда вы используете относительные пути.

Понимание текущего рабочего каталога важно, потому что он определяет, где Python будет искать файл, когда вы используете относительный путь вроде "data.txt". Если вы запускаете скрипт из /home/alice/projects/ и открываете "data.txt", Python будет искать /home/alice/projects/data.txt.

27.1.2) Эффективное использование относительных путей

При работе с файлами относительные пути часто удобнее абсолютных, потому что они делают ваш код переносимым — он работает независимо от того, где находится папка проекта на разных компьютерах.

Вот распространённые шаблоны относительных путей:

# Файл в текущем рабочем каталоге
filename = "student_grades.txt"
 
# Файл в подкаталоге (папка data внутри текущего каталога)
filename = "data/student_grades.txt"
 
# Файл в родительском каталоге
filename = "../shared_data.txt"

Для примеров этой главы мы будем в основном использовать простые имена файлов, такие как "data.txt". Это означает:

• файлы данных должны находиться в том же каталоге, из которого вы запускаете команду Python
• если ваш скрипт находится в /home/alice/projects/ и вы запускаете python script.py из этого каталога, Python будет искать data.txt в /home/alice/projects/

Этот подход делает примеры понятными и сосредоточенными на файловых операциях, а не на навигации по путям. Если вы получаете FileNotFoundError, используйте os.getcwd(), чтобы проверить, где Python ищет файлы.

27.1.3) Разделители путей в разных операционных системах

Разные операционные системы используют разные символы для разделения каталогов в путях:

• Windows использует обратные слеши: data\reports\sales.txt
• macOS и Linux используют прямые слеши: data/reports/sales.txt

Python обрабатывает это автоматически, когда вы используете прямые слеши в своём коде — они работают во всех операционных системах:

# Это работает в Windows, macOS и Linux
filename = "data/reports/sales.txt"

Python преобразует прямые слеши в соответствующий разделитель для вашей операционной системы.

27.2) Открытие и закрытие файлов

Чтобы работать с файлом, мы сначала должны открыть его, что создаёт соединение между нашей программой и файлом на диске. Когда мы закончим, мы должны закрыть его, чтобы освободить системные ресурсы и убедиться, что все данные корректно сохранены.

27.2.1) Функция open()

Функция open() создаёт файловый объект, который представляет соединение с файлом. В самом простом варианте вы указываете имя файла:

# Открыть файл для чтения (режим по умолчанию)
file = open("message.txt")

Это открывает файл message.txt в текущем каталоге. Функция open() возвращает файловый объект, который мы сохраняем в переменной file. Этот объект предоставляет методы для чтения из файла или записи в файл.

Однако у этого базового подхода есть критическая проблема: если после открытия файла произойдёт ошибка, файл может так и не быть закрыт. Давайте посмотрим, почему закрытие файлов важно.

27.2.2) Почему важно закрывать файлы

Когда вы открываете файл, операционная система выделяет ресурсы для поддержания этого соединения. Если вы не закрываете файл:

• Данные могут не сохраниться: при записи в файл данные часто буферизуются в памяти и записываются на диск только при закрытии файла
• Системные ресурсы тратятся впустую: каждый открытый файл потребляет память и файловые дескрипторы
• Другие программы могут быть заблокированы: некоторые системы не позволяют другим программам получить доступ к файлу, который уже открыт

Чтобы закрыть файл, вызовите метод close():

file = open("message.txt")
# ... работа с файлом ...
file.close()  # Освободить ресурсы и убедиться, что данные сохранены

27.2.3) Проблема ручного закрытия

Ручное закрытие файлов подвержено ошибкам. Если между открытием и закрытием происходит исключение, вызов close() может не выполниться:

file = open("data.txt")
result = process_data(file)  # Если здесь возникнет исключение...
file.close()  # ...это не выполнится!

Это настолько распространённая проблема, что Python предоставляет лучшее решение: оператор with, о котором мы узнаем в разделе 27.4. Пока что поймите, что открытие и закрытие файлов вручную требует внимательности, чтобы close() вызывался всегда.

27.2.4) Проверка, открыт ли файл

У файлового объекта есть атрибут closed, который сообщает, закрыт файл или нет:

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

После закрытия файла попытка читать из него или писать в него приведёт к ошибке:

file = open("data.txt")
file.close()
 
# Это вызовет ValueError: I/O operation on closed file
content = file.read()

Сообщение об ошибке ясно указывает проблему: вы пытаетесь выполнить операцию ввода-вывода (I/O) над файлом, который уже закрыт.

27.3) Понимание режимов файлов (r, w, a, текстовый vs двоичный) и кодировки

При открытии файла вы можете указать режим (mode), который определяет, какие операции разрешены и как файл обрабатывается. Понимание режимов критически важно для корректной работы с файлами.

27.3.1) Текстовый режим vs двоичный режим

Файлы можно открывать в двух фундаментальных режимах:

Текстовый режим (по умолчанию) рассматривает файл как содержащий текст. Python автоматически:

• Приводит окончания строк к \n независимо от платформы
• Обрабатывает кодировку текста (преобразование между байтами и строками)
• Позволяет читать и записывать строки

Двоичный режим рассматривает файл как «сырые» байты. Python:

• Читает и записывает объекты bytes, а не строки
• Не выполняет никаких преобразований или интерпретаций
• Используется для изображений, аудио, видео и других нетекстовых файлов

В этой главе мы сосредоточимся на текстовом режиме, который вы будете использовать чаще всего. Двоичный режим обозначается добавлением 'b' к строке режима (например, 'rb' или 'wb'), но для текстовых файлов он нам не понадобится.

27.3.2) Три основных режима файлов

Python предоставляет три основных режима для открытия текстовых файлов:

Режим чтения ('r') — открывает файл только для чтения:

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

• Файл должен уже существовать, иначе Python выдаст FileNotFoundError
• Вы можете читать из файла, но не можете записывать в него
• Это режим по умолчанию, если вы его не укажете

Режим записи ('w') — открывает файл для записи:

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

• Создаёт файл, если он не существует
• Стирает всё существующее содержимое, если файл уже существует
• Вы можете писать в файл, но не можете читать из него
• Используйте это, когда хотите создать новый файл или полностью заменить существующий

Режим добавления ('a') — открывает файл для добавления в конец:

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

• Создаёт файл, если он не существует
• Сохраняет существующее содержимое и добавляет новое в конец
• Вы можете писать в файл, но не можете читать из него
• Используйте это, когда хотите дописывать в существующий файл, не теряя его текущего содержимого

Вот сравнение того, как эти режимы влияют на существующий файл:

# Предположим, data.txt содержит: "Hello\nWorld\n"
 
# Режим чтения — содержимое не меняется
file = open("data.txt", "r")
file.close()
# Файл всё ещё содержит: "Hello\nWorld\n"
 
# Режим записи — содержимое стирается
file = open("data.txt", "w")
file.write("New content\n")
file.close()
# Теперь файл содержит: "New content\n"
 
# Режим добавления — содержимое сохраняется, новое добавляется
file = open("data.txt", "a")
file.write("Added line\n")
file.close()
# Теперь файл содержит: "New content\nAdded line\n"

27.3.3) Понимание кодировки текста

Когда вы работаете с текстовыми файлами, Python должен знать, как преобразовывать байты, хранящиеся на диске, в строковые символы в вашей программе и обратно. Этот процесс преобразования называется кодировкой (encoding).

Самая распространённая кодировка — UTF-8, которая может представить любой символ любого языка. Это кодировка по умолчанию в Python 3 и стандарт для современных текстовых файлов.

# Явно указать кодировку UTF-8 (хотя обычно она и так по умолчанию)
file = open("data.txt", "r", encoding="utf-8")

Почему кодировка важна? Рассмотрим текстовый файл, содержащий имя с буквой с диакритикой:

# Запись файла со специальными символами
file = open("names.txt", "w", encoding="utf-8")
file.write("José\n")
file.write("François\n")
file.write("Müller\n")
file.close()
 
# Чтение обратно
file = open("names.txt", "r", encoding="utf-8")
content = file.read()
file.close()
print(content)

Output:

José
François
Müller

Если вы попытаетесь открыть файл с неправильной кодировкой, вы можете увидеть «кракозябры» или получить ошибку. Всегда используйте UTF-8 для новых файлов, если у вас нет конкретной причины использовать другую кодировку.

27.3.4) Дополнительные варианты режимов

Python предоставляет дополнительные символы режимов, которые можно комбинировать с основными режимами:

Режимы с плюсом позволяют и читать, и писать:

• 'r+' — чтение и запись (файл должен существовать)
• 'w+' — запись и чтение (стирает существующее содержимое)
• 'a+' — добавление и чтение (сохраняет существующее содержимое)

Для начинающих понятнее открывать файл один раз для чтения и отдельно для записи, чем использовать режимы с плюсом. В этой главе мы будем придерживаться простых режимов ('r', 'w', 'a').

27.4) Использование with для автоматического управления файлами

Оператор with предоставляет более чистый и безопасный способ работы с файлами. Он автоматически закрывает файл, когда вы заканчиваете, даже если возникает ошибка.

27.4.1) Синтаксис оператора with

Вот как использовать with для открытия файла:

with open("data.txt", "r") as file:
    content = file.read()
    print(content)
# Файл автоматически закрывается здесь

Этот синтаксис состоит из нескольких частей:

• with — ключевое слово, которое начинает контекстный менеджер(context manager)
• open("data.txt", "r") — открывает файл
• as file — создаёт переменную для ссылки на файловый объект
• : — начинает блок с отступом
• Блок с отступом — код, который работает с файлом
• После блока — файл автоматически закрывается

Ключевое преимущество: Python гарантирует, что файл будет закрыт, когда блок with заканчивается, независимо от того, как он заканчивается (нормально, через return или из-за исключения).

27.4.2) Почему with лучше ручного закрытия

Сравните эти два подхода:

# Ручное закрытие — рискованно
file = open("data.txt", "r")
content = file.read()
result = process(content)  # Если здесь возникнет исключение...
file.close()  # ...это не выполнится
 
# Использование with — безопасно
with open("data.txt", "r") as file:
    content = file.read()
    result = process(content)  # Даже если здесь возникнет исключение...
# ...файл всё равно будет закрыт автоматически

Оператор with использует протокол контекстного менеджера (context manager protocol), который мы подробно рассмотрим в главе 28. Пока что воспринимайте это как гарантию: «Я освобожу этот ресурс, когда вы закончите, независимо от того, что произойдёт».

27.4.3) Работа с несколькими файлами

Вы можете открыть несколько файлов в одном операторе with:

with open("input.txt", "r") as infile, open("output.txt", "w") as outfile:
    content = infile.read()
    outfile.write(content.upper())
# Оба файла автоматически закрываются здесь

Это полезно, когда вам нужно одновременно читать из одного файла и писать в другой. Гарантируется, что оба файла будут корректно закрыты, даже если возникает ошибка.

27.4.4) Файловый объект действителен только внутри блока with

Когда блок with заканчивается, файл закрывается, и вы больше не можете использовать файловый объект:

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
 
# Это вызовет ValueError: I/O operation on closed file
more_content = file.read()

Это поведение задумано — оно предотвращает случайное использование закрытого файла. Если вам нужно содержимое файла вне блока with, сохраните его в переменную (как content выше) до завершения блока.

Начиная с этого момента в главе, мы будем использовать with для всех операций с файлами. Это рекомендуемый подход и то, что вам следует использовать в своём собственном коде.

27.5) Чтение текстовых файлов

Теперь, когда мы понимаем, как безопасно открывать файлы с помощью with, давайте рассмотрим разные способы чтения содержимого текстовых файлов.

27.5.1) Чтение всего файла с помощью read()

Метод read() читает всё содержимое файла как одну строку:

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

Если message.txt содержит:

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.

Метод read() включает все символы перевода строки (\n) из файла. Когда вы печатаете строку, Python отображает каждую строку на отдельной строке из-за этих символов перевода строки.

Вы также можете прочитать определённое количество символов, передав число в read():

with open("message.txt", "r") as file:
    first_ten = file.read(10)  # Прочитать первые 10 символов
    print(f"First 10 characters: '{first_ten}'")

Output:

First 10 characters: 'Welcome to'

Чтение всего файла целиком — просто и хорошо подходит для небольших файлов. Однако для больших файлов (мегабайты или гигабайты) чтение всего сразу может потреблять слишком много памяти. Для таких случаев чтение построчно более эффективно.

27.5.2) Чтение построчно с помощью readline()

Метод readline() читает одну строку из файла, включая символ перевода строки в конце:

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.
 

Обратите внимание на лишние пустые строки в выводе. Каждая строка, прочитанная из файла, заканчивается \n, а print() добавляет ещё один перевод строки. Чтобы этого избежать, используйте метод rstrip() для удаления пробельных символов в конце строки:

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.

Когда readline() достигает конца файла, он возвращает пустую строку "". Это позволяет определить, что строк для чтения больше нет:

with open("message.txt", "r") as file:
    while True:
        line = file.readline()
        if line == "":  # Конец файла
            break
        print(line.rstrip())

Однако есть более «питоничный» способ читать файлы построчно.

27.5.3) Итерация по строкам с помощью цикла for

Файловые объекты итерируемы (iterable), то есть вы можете перебирать их напрямую с помощью цикла for. Это самый распространённый и «питоничный» способ читать файл построчно:

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.

Этот подход:

• Чище: не нужно readline() или проверок на пустые строки
• Эффективнее: Python читает файл порциями, не загружая весь файл в память
• Более Pythonic: использует итерацию, которая является базовой концепцией Python

Каждая итерация цикла читает следующую строку из файла. Когда строки заканчиваются, цикл автоматически завершается.

27.5.4) Чтение всех строк в список с помощью readlines()

Метод readlines() читает все строки из файла и возвращает их как список строк:

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.

Каждый элемент списка — это строка, содержащая одну строку из файла, включая символ перевода строки. Это полезно, когда вам нужно:

• обращаться к строкам по индексу: lines[0], lines[1] и т. д.
• обрабатывать строки несколько раз
• знать общее количество строк до обработки

Однако, как и read(), readlines() загружает весь файл в память. Для больших файлов итерация с помощью цикла for более экономична по памяти.

27.6) Запись в текстовые файлы и добавление в конец

Запись в файлы так же важна, как и чтение из них. Python предоставляет простые методы для создания новых файлов или изменения существующих.

27.6.1) Запись в файл с помощью write()

Чтобы записывать в файл, откройте его в режиме записи ('w') и используйте метод write():

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

После выполнения этого кода output.txt содержит:

Hello, World!
This is a new file.

Важные моменты про write():

• Он записывает строку в файл
• Он не добавляет символы перевода строки автоматически — вы должны включать \n сами
• Он возвращает количество записанных символов (хотя обычно мы это игнорируем)
• Если файл уже существует, режим записи стирает всё существующее содержимое перед записью

Посмотрим, что произойдёт, когда мы пишем в существующий файл:

# Сначала создадим файл с некоторым содержимым
with open("demo.txt", "w") as file:
    file.write("Original content\n")
 
# Теперь откроем его снова в режиме записи
with open("demo.txt", "w") as file:
    file.write("New content\n")
 
# Прочитаем файл, чтобы увидеть, что в нём содержится
with open("demo.txt", "r") as file:
    print(file.read())

Output:

New content

Исходное содержимое пропало. Режим записи всегда начинает с пустого файла — независимо от того, создаёте ли вы новый файл или перезаписываете существующий.

27.6.2) Запись нескольких строк

Вы можете вызывать write() несколько раз, чтобы записать несколько строк:

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

27.6.3) Запись данных из коллекций

Распространённая задача — записать данные из списков или других коллекций в файл:

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

Это создаст students.txt, содержащий:

Alice
Bob
Carol
David

27.6.4) Добавление в конец файла

Когда вы хотите добавить содержимое в конец существующего файла, не стирая то, что уже там есть, используйте режим добавления ('a'):

# Создать файл с начальным содержимым
with open("log.txt", "w") as file:
    file.write("Program started\n")
 
# Позже добавить больше содержимого
with open("log.txt", "a") as file:
    file.write("Processing data\n")
    file.write("Processing complete\n")
 
# Прочитать файл, чтобы увидеть всё содержимое
with open("log.txt", "r") as file:
    print(file.read())

Output:

Program started
Processing data
Processing complete

Режим добавления идеально подходит для лог-файлов, где вы хотите вести непрерывную запись событий. Каждый раз, когда вы открываете файл в режиме добавления, новое содержимое добавляется в конец, сохраняя всё, что уже было.

27.7) Обработка распространённых ошибок файлового ввода-вывода

Файловые операции могут завершаться неудачей по многим причинам: файл не существует, у вас нет прав доступа к нему, диск заполнен или файл уже открыт другой программой. Умение корректно обрабатывать эти ошибки делает ваши программы более надёжными и удобными для пользователя.

27.7.1) FileNotFoundError: когда файла не существует

Самая распространённая файловая ошибка возникает, когда вы пытаетесь прочитать файл, которого не существует:

# ВНИМАНИЕ: Это вызовет FileNotFoundError, если data.txt не существует
with open("data.txt", "r") as file:
    content = file.read()

Если data.txt не существует, Python выдаст:

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

Чтобы обработать это корректно, используйте блок try-except (как мы изучали в главе 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 (if file doesn't exist):

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

Этот подход предотвращает падение программы и выдаёт пользователю полезное сообщение.

27.7.2) PermissionError: когда вы не можете получить доступ к файлу

Иногда у вас нет прав читать или записывать файл:

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.")

Ошибки прав доступа могут возникать, когда:

• файл принадлежит другому пользователю
• файл находится в защищённом системном каталоге
• файл помечен как только для чтения, а вы пытаетесь записать в него
• в Windows файл открыт в другой программе

27.7.3) IsADirectoryError: когда вы пытаетесь открыть каталог

Если вы случайно пытаетесь открыть каталог вместо файла:

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

Это может случиться, когда у вас есть и файл, и каталог с похожими именами, или когда вы забываете включить имя файла в путь.

27.7.4) UnicodeDecodeError: когда кодировка не совпадает

Если вы пытаетесь прочитать файл с неправильной кодировкой, вы можете получить 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.")

Эта ошибка возникает, когда файл содержит байты, которые не являются валидным UTF-8. Если вы сталкиваетесь с этим, файл может:

• использовать другую кодировку (например, Latin-1 или Windows-1252)
• быть двоичным файлом, который вы пытаетесь прочитать как текст
• быть повреждённым

27.7.5) Обработка нескольких типов ошибок

Вы можете перехватывать несколько типов ошибок в одном блоке 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.")

Это предоставляет конкретные, полезные сообщения об ошибках для каждого типа проблемы. Пользователь точно знает, что пошло не так, и может предпринять соответствующие действия.

27.7.6) Использование универсального обработчика исключений

Иногда вы хотите перехватывать любые неожиданные ошибки, связанные с файлами, помимо конкретных типов, которые мы рассмотрели. Вы можете использовать общий обработчик Exception как универсальный вариант после ваших специфичных обработчиков:

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}")

Это гарантирует, что ваша программа обработает даже ошибки, которые вы не предвидели. Переменная e содержит объект исключения, который включает описательное сообщение об ошибке. Его вывод даёт пользователю технические детали о том, что пошло не так.

Работа с файлами — фундаментальный навык в программировании. Вы узнали, как:

• Понимать пути к файлам и текущий рабочий каталог
• Правильно открывать и закрывать файлы
• Использовать разные режимы файлов для чтения, записи и добавления
• Автоматически управлять файлами с помощью оператора with
• Читать файлы разными способами (read(), readline(), итерация, readlines())
• Записывать в файлы и добавлять в конец содержимое
• Корректно обрабатывать распространённые ошибки файлового ввода-вывода

Эти навыки позволяют создавать программы, которые сохраняют данные между запусками, обрабатывают текстовые файлы, генерируют отчёты и многое другое. В следующей главе мы подробно рассмотрим контекстные менеджеры(context managers), поймём механизм, который заставляет оператор with работать, и узнаем, как создавать собственные контекстные менеджеры для управления ресурсами помимо файлов.