Предыдущий урок показал, как расширять программу чужим кодом через модули и импорт, и настало время научить её запоминать данные дольше, чем живёт один запуск. Пока всё хранится в переменных, результат работы скрипта исчезает вместе с закрытым терминалом. Файлы снимают это ограничение: заметки, журналы событий, списки задач, настройки приложения можно записать на диск и прочитать обратно завтра, через месяц или вообще на другом компьютере. Хорошая новость в том, что Python сделал работу с файлами по-человечески простой. Вся базовая механика держится на одной функции open, горстке методов и менеджере контекста with, который бережно закрывает файл даже там, где новичок забыл бы это сделать. Дальше всё по порядку, а в конце собран готовый сценарий со списком покупок.
Функция open и режимы открытия файла
Любая работа с файлом начинается с вызова функции open. Она получает путь к файлу и режим работы, а возвращает файловый объект, через который дальше идут все операции чтения и записи.
f = open("notes.txt", "r")
print(f)
# <_io.TextIOWrapper name='notes.txt' mode='r' encoding='UTF-8'>
Режимов немного, и каждый отвечает за своё. Режим r от слова read открывает файл только для чтения, это значение по умолчанию, его можно вовсе не писать. Режим w от слова write открывает файл для записи и создаёт его, если файла ещё нет, но у этой медали есть обратная сторона: существующий файл очищается мгновенно, ещё до первой записанной буквы. Режим a от слова append открывает файл для дозаписи в конец, он тоже создаёт отсутствующий файл, зато никогда не трогает уже сохранённые данные.
f = open("notes.txt") # режим r подставился сам
f = open("notes.txt", "w") # запись, прежнее содержимое стёрто
f = open("notes.txt", "a") # дозапись в конец, прежнее цело
Для бинарных данных, картинок, звуков и архивов, существуют парные режимы rb, wb и ab, они работают с потоком байтов вместо текста. Есть и комбинированные режимы r+ и w+, открывающие файл одновременно на чтение и запись, но на старте курса они почти не нужны: уверенного владения тройкой r, w, a хватает с головой.
Файловый объект не молчаливая коробка, у него есть полезные атрибуты, которые помогают отлаживать код.
f = open("notes.txt", "r", encoding="utf-8")
print(f.name) # notes.txt
print(f.mode) # r
print(f.closed) # False
f.close()
print(f.closed) # True
Отдельного разговора заслуживает поведение режима r, когда файла с таким именем на диске нет: Python честно выбрасывает ошибку FileNotFoundError, а не создаёт пустой файл молча. Пугаться traceback не стоит, сообщение прямо называет причину - No such file or directory. Второй источник внезапных ошибок - путь. open ищет файл относительно текущей рабочей папки, а не относительно папки, где лежит сам скрипт, поэтому программа, запущенная из другого места, не находит notes.txt, хотя тот точно лежит рядом с кодом.
Чтение файла целиком и построчно
Прочитать текст можно несколькими способами, и каждый выручает в своей ситуации. Метод read() считывает весь файл целиком и возвращает одну длинную строку со всеми переносами. Если передать read() целое число, он прочитает ровно столько символов. Метод readlines() возвращает список строк, где каждый элемент отвечает за одну строку файла. Есть и метод readline(), читающий по одной строке за вызов, он выручает при ручном пошаговом обходе. А самый элегантный приём - пройтись по файловому объекту обычным циклом for: Python сам читает файл построчно и не тащит в память всё содержимое разом, что особенно ценно на больших файлах.
with open("notes.txt", encoding="utf-8") as f:
text = f.read() # весь файл одной строкой
print(text)
with open("notes.txt", encoding="utf-8") as f:
for line in f: # построчно, экономно по памяти
print(line.strip()) # strip снимает невидимый \n на конце
Здесь прячется мелочь, которая ставит в тупик почти каждого. Прочитанная из файла строка несёт на конце невидимый символ переноса \n, поэтому print добавляет поверх него ещё один свой перенос, и на экране вырастают лишние пустые строки. Метод strip() аккуратно отрезает висячие пробелы и переносы, после чего вывод выглядит как задумано.
with open("notes.txt", encoding="utf-8") as f:
lines = f.readlines()
print(len(lines)) # 3 - столько строк в файле
print(lines[0]) # первая строка вместе с \n на конце
У файлового объекта есть ещё невидимая деталь - курсор, позиция, с которой продолжается чтение. После первого read() курсор стоит в самом конце файла, и второй read() вернёт пустую строку, ведь читать уже нечего. Метод seek(0) возвращает курсор в начало, но чаще проще закрыть файл и открыть заново.
with open("notes.txt", encoding="utf-8") as f:
f.read()
print(repr(f.read())) # '', читать больше нечего
Числа из файла приходят строками, поэтому для расчётов их превращают обратно через int или float.
with open("temps.txt", encoding="utf-8") as f:
temps = [float(line) for line in f]
print(round(sum(temps) / len(temps), 2)) # средняя температура
Запись данных в файл и дозапись в конец
Для записи у файлового объекта есть метод write. Он принимает строку и возвращает количество записанных символов. Главная ловушка, на которую наступают все без исключения: write не добавляет перенос строки автоматически. Чтобы каждая запись оказалась на новой строке, перенос \n добавляют вручную.
with open("log.txt", "w", encoding="utf-8") as f:
f.write("Первая запись в журнале\n")
f.write("Вторая запись\n")
print(f.write("Третья запись\n"))
# 14 - столько символов вернул write
Вторая ловушка - типы. write принимает только строки, число нужно предварительно превратить в текст функцией str, иначе Python выбросит TypeError.
count = 42
with open("state.txt", "w", encoding="utf-8") as f:
f.write(str(count)) # только строки, потому str()
Режим w перезаписывает файл с чистого листа. Запустили скрипт во второй раз - от вчерашнего журнала не осталось и следа. Если данные должны накапливаться день за днём, выручает режим a, дозапись в конец.
with open("log.txt", "a", encoding="utf-8") as f:
f.write("Эта строка добавилась в конец\n")
Теперь в log.txt лежат все три строки, хотя файл открывался уже дважды, и ничего не пропало. Есть и помощник для массовой записи - метод writelines, который принимает список строк и отправляет их в файл подряд, правда, без переносов, если сами строки их не содержат.
lines = ["молоко\n", "хлеб\n", "яйца\n"]
with open("shopping.txt", "w", encoding="utf-8") as f:
f.writelines(lines)
Ещё одна тонкость связана с буфером. Python не отправляет каждый символ на диск сразу, он складывает данные в буфере и выгружает порциями. При штатном закрытии файла всё долетает до диска автоматически, а вот при резком обрыве программы посреди записи хвост может потеряться. Отсюда простое правило: файл закрыт - данные на диске целиком.
Менеджер контекста with и закрытие файла
Ручное управление файлом поначалу выглядит невинно: открыл, поработал, закрыл.
f = open("notes.txt", encoding="utf-8")
text = f.read()
f.close()
Проблема всплывает, когда между open и close случается ошибка. Python выполняет строки сверху вниз, доходит до проблемного места, выбрасывает исключение и уходит, так и не выполнив f.close(). Файл остаётся открытым до самого конца работы программы. В коротком скрипте это незаметно, а в сервисе, который трудится сутками, десятки брошенных файловых объектов приводят к загадочным сбоям, к упору в лимит операционной системы на открытые файлы и к невозможности удалить или переименовать файл, который кто-то продолжает держать.
Менеджер контекста with решает задачу раз и навсегда. Он гарантирует вызов close при выходе из блока, что бы ни случилось внутри: обычное завершение, ошибка, досрочный выход - файл закроется.
with open("notes.txt", encoding="utf-8") as f:
text = f.read()
# здесь файл уже закрыт, даже если внутри блока была ошибка
Файл живёт ровно внутри отступа, и это наглядно: глядя на код, сразу видно, где открытый файл ещё нужен, а где он уже неактуален. with умеет открывать несколько файлов сразу, что удобно, например, при переносе текста из одного файла в другой.
with open("source.txt", encoding="utf-8") as src, \
open("copy.txt", "w", encoding="utf-8") as dst:
dst.write(src.read())
Сравнение честное: ручной close выглядит короче, зато with надёжнее в каждом сценарии, где что-то может пойти не так, а в реальной жизни что-то идёт не так всегда. Профессиональный Python-код почти не содержит голых open без with, и приучить себя к этой привычке лучше с первой же недели.
Кодировка encoding и русский текст
Файл на диске хранит не буквы, а байты, и чтобы из байтов снова получились русские буквы, нужны правила перевода, то есть кодировка. Общепринятый стандарт сегодня - UTF-8, он понимает и русский, и китайский, и эмодзи, и почти любой язык планеты. Если кодировку не указать явно, Python возьмёт системную, а она у разных операционных систем разная: на Linux и macOS это обычно UTF-8, на Windows - cp1251, рассчитанная на кириллицу, но только на неё.
Отсюда классическая беда новичка: на домашнем компьютере файл читается идеально, а у коллеги с другой системой вместо русских букв вырастают кракозябры, или программа падает с UnicodeDecodeError. Лечится это одним словом в каждой операции с файлом.
with open("letter.txt", "w", encoding="utf-8") as f:
f.write("Привет, мир! Здесь русский текст.")
with open("letter.txt", encoding="utf-8") as f:
print(f.read()) # Привет, мир! Здесь русский текст.
Правило стоит вбить в мышечную память: encoding="utf-8" пишется и при записи, и при чтении, всегда. Одинаковая кодировка на входе и на выходе гарантирует, что текст вернётся ровно таким, каким его сохранили. Если файл пришёл из старой программы и при чтении падает ошибка, первым делом стоит попробовать кодировку cp1251, в которой когда-то жили текстовые документы с кириллицей.
with open("old_notes.txt", encoding="cp1251") as f:
print(f.read())
Полный сценарий сохранения списка покупок в файл
Теория складывается в практику, когда появляется настоящая задача. Список покупок, который дополняется от запуска к запуску и переживает выключение компьютера, подходит идеально. Две маленькие функции решают её целиком: одна сохраняет список в файл, другая читает его обратно.
def save_shopping(items, filename="shopping.txt"):
with open(filename, "w", encoding="utf-8") as f:
for item in items:
f.write(item + "\n")
def load_shopping(filename="shopping.txt"):
items = []
with open(filename, "r", encoding="utf-8") as f:
for line in f:
items.append(line.strip())
return items
shopping = ["молоко", "хлеб", "яйца", "сыр"]
save_shopping(shopping)
loaded = load_shopping()
print(loaded) # ['молоко', 'хлеб', 'яйца', 'сыр']
loaded.append("чай")
save_shopping(loaded)
print(load_shopping()) # ['молоко', 'хлеб', 'яйца', 'сыр', 'чай']
Теперь по шагам. В функции save_shopping файл открывается в режиме w с явной кодировкой, и каждый пункт записывается на своей строке. Функция load_shopping открывает тот же файл, идёт по нему циклом for и собирает строки обратно в список, попутно снимая \n методом strip. Первый запуск сохраняет четыре пункта, затем список пополняется словом "чай" и сохраняется снова. Второй вывод показывает уже пять пунктов: файл честно пережил перезапуск программы, хотя сама программа об этом ничего не помнила.
Пара строк превращает сценарий в живой инструмент. Новое имя товара вводится с клавиатуры через input и тут же дозаписывается в конец файла, без перезаписи всего списка:
new_item = input("Что добавить в список? ")
with open("shopping.txt", "a", encoding="utf-8") as f:
f.write(new_item + "\n")
print(load_shopping())
Такой парой функций на диске спокойно живут и список дел, и результаты игры, и показания за неделю. Хранение получается простым, зато полностью прозрачным: файл открывается обычным блокнотом, и внутри видно ровно то, что ожидалось.
Частые ошибки при работе с файлами
Начинающие программисты упорно повторяют одни и те же промахи, и короткий перечень сбережёт не один час отладки:
- Открыть файл в режиме w ради одной дополнительной строки и стереть всё прежнее содержимое; для добавления данных существует режим a;
- Забыть encoding="utf-8" и получить кракозябры на другом компьютере; кодировка указывается и при записи, и при чтении;
- Пытаться читать файл, открытый на запись, и ловить io.UnsupportedOperation; режим должен совпадать с задуманной операцией;
- Читать из файла, куда только что писали тем же объектом, и получать пустую строку; курсор стоит в конце, его возвращает в начало метод seek(0);
- Держать файл открытым без with и удивляться недописанному хвосту; без закрытия буфер может не выгрузиться на диск целиком.
Проверка привычки простая: любой open в собственном коде должен стоять внутри with и нести encoding="utf-8". Когда этот рефлекс сработает, файлы перестанут быть источником сюрпризов и превратятся в спокойный рабочий инструмент.
Файловые операции - последний крупный кирпич фундамента Python. Следующий урок отдаст работу с путями модулю pathlib и покажет формат JSON, в котором удобно хранить сложные данные со вложенными списками и словарями, а значит, список покупок научится хранить и цены, и количества.