Файлы: чтение и запись – Учебник

8.4

О чём этот урок

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

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

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

В этом уроке: что такое файл для программы и зачем ему кодировка; как открыть файл функцией open() и что делает каждый из режимов 'r', 'w' и 'a'; почему закрывать файл доверяют with; способы прочитать файл; главная ловушка – перевод строки \n в конце каждой строки; как записать результат в файл и как дописать его в конец; где программа ищет файл и что значит FileNotFoundError.

Файл глазами программы

Всё, что программа знает, живёт в переменных, а переменные живут, пока работает программа.

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

Имя файла – это на самом деле путь, то есть адрес, по которому его искать. Короткое имя data.txt адресует файл рядом с программой, полное – конкретное место на диске; об этом ниже, в отдельном блоке.

Дальше важная подробность: на диске текст лежит не символами, а байтами, а кодировка – то самое правило перевода одного в другое, которым занят весь блок 7. Поэтому при чтении файла мало сказать, что открыть, – надо ещё указать, в какой кодировке написан текст, иначе получатся кракозябры из урока 7.2. Проще всего её не угадывать, а договориться заранее: файлы пишут в UTF-8, и её же используют при открытии.

И ещё одно, что неочевидно: для программы текстовый файл – это одна длинная последовательность символов, разбитая на строки переводом строки. Никаких отдельных «записей» и «ячеек» там нет: строка кончается там, где стоит \n. Сколько их в файле, программа заранее не знает – она читает, пока строки не кончатся.

`open()`: три вещи в одной строке

Открывает файл встроенная функция open():

f = open('numbers.txt', 'r', encoding='utf-8')
...
f.close()

open(путь, режим, encoding='utf-8') – открывает файл и возвращает объект файла: то, через что дальше идёт вся работа – чтение, запись, закрытие.

В строке названы три вещи: что открыть (путь), как открыть (режим) и в какой кодировке читать написанное.

encoding='utf-8' указывают всегда. Не «когда понадобится», не «если в файле русские буквы», а в каждом open(), даже если сегодня файл читается правильно. Без этого аргумента Python берёт кодировку системы. На Windows это не UTF-8, поэтому файл с русским текстом либо прочитается как набор нечитаемых символов, либо чтение упадёт с UnicodeDecodeError. Это не теоретическая придирка, а первая ошибка, с которой сталкиваются все, кто начинает читать файлы: на одном компьютере программа работает, на другом выдаёт вместо текста мусор.

Режим отвечает на вопрос, что программа собирается делать с файлом. Режимов три:

Режим	Что делает	Файла нет	Файл есть
`'r'`	чтение, режим по умолчанию	ошибка `FileNotFoundError`	читает с начала
`'w'`	запись	создаст	сотрёт содержимое сразу при открытии
`'a'`	дописывание в конец	создаст	оставит содержимое, добавит в конец

Режим 'w' стирает содержимое сразу при открытии – ещё до первой записи. Не тогда, когда программа что-то запишет, а в тот момент, когда open() вернул объект файла.

Режим 'r' в записи обычно опускают: он и так по умолчанию. Но именно он объясняет, почему чтение несуществующего файла падает: читать нечего, и FileNotFoundError – честный ответ.

`with`: файл закрывается сам

Открытый файл – ресурс, который система отдаёт программе на время. Взял – верни. Дело не в аккуратности: write() не пишет на диск сразу, а складывает данные в буфер, и в файл их переносит закрытие.

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

f = open('lines.txt', 'w', encoding='utf-8')
f.write('первая\n')
print(open('lines.txt', encoding='utf-8').read())   # пусто!

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

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

with open(путь, режим, encoding='utf-8') as f: – открывает файл и закрывает его сам, когда блок кончился.

«Сам» здесь значит буквально сам: закрытие произойдёт и при обычном выходе из блока, и если внутри случилась ошибка – with закроет файл раньше, чем ошибка полетит дальше. Разница видна рядом:

# закрывать руками: до строки f.close() файл открыт,
# а если посередине случится ошибка – не закроется вовсе
f = open('numbers.txt', encoding='utf-8')
text = f.read()
f.close()

# закрытие устроено языком, а не программистом
with open('numbers.txt', encoding='utf-8') as f:
    text = f.read()

Без with пришлось бы звать f.close() руками – и следить за тем, чтобы он вызвался на всех путях, включая путь с ошибкой. with снимает эту заботу целиком, поэтому в нём открывают почти все файлы: лишней работы он не делает, а забыть закрыть файл просто не даёт.

# в файле numbers.txt записаны три строки:
#   12
#   7
#   100

with open('numbers.txt', encoding='utf-8') as f:
    text = f.read()        # весь файл одной строкой

print(text)
# 12
# 7
# 100
# print() печатает строку как она есть, вместе со всеми
# переводами строк – поэтому каждая строка встала на своё
# место, хотя в переменной лежит одна длинная строка

Три способа прочитать

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

Способ	Что возвращает	Когда брать
`f.read()`	весь файл одной строкой, вместе со всеми `\n` внутри	файл небольшой и нужен целиком
`f.readline()`	одну строку, вместе с `\n` в конце	строки разбирают по одной и строго по порядку
`for line in f:`	ничего: строку за строкой отдаёт цикл	обычный случай – файл любого размера, в памяти живёт одна строка
`f.readlines()`	список всех строк сразу	нужен доступ к строкам по номеру (что такое список – блок 9)

Способов, если считать строго, три с половиной: readlines() – это весь файл, разложенный в список строк. Работа та же, что у read(), и память та же; отличается только вид результата.

Почему цикл называют обычным случаем. read() держит в памяти весь файл сразу, а for line in f – одну строку за раз. Файл на сто тысяч строк read() прочитает только на машине с достаточной памятью, а цикл – на любой: он не хранит прочитанное, а обрабатывает и забывает.

И деталь, из-за которой примеры ниже открывают файл заново. Объект файла помнит, где остановился: после read() следующий read() вернёт пустую строку, а после readline() следующий вернёт уже вторую строку. Файл не перематывается к началу сам, поэтому второй проход начинают новым open().

# numbers.txt: 12, 7, 100 – три строки, каждая с \n на конце

# 1. весь файл одной строкой
with open('numbers.txt', encoding='utf-8') as f:
    text = f.read()
print(text.count('\n'))   # 3 – столько в файле переводов строки
print(text)                # 12 / 7 / 100 – три строки на экране

# 2. по одной строке вручную
with open('numbers.txt', encoding='utf-8') as f:
    line1 = f.readline()   # '12\n' – перевод строки внутри
    line2 = f.readline()   # '7\n'
    line3 = f.readline()   # '100\n'
    line4 = f.readline()   # '' – пустая строка: файл кончился
print(line1 + line2 + line3)   # 12 / 7 / 100

# 3. циклом – обычный случай
with open('numbers.txt', encoding='utf-8') as f:
    for line in f:
        print(line, end='')    # end='' не добавляет свой перевод

# 3 с половиной: весь файл списком строк
with open('numbers.txt', encoding='utf-8') as f:
    lines = f.readlines()
print(lines)               # ['12\n', '7\n', '100\n']
print(len(lines))          # 3 – столько строк в файле

Ловушка: `\n` в конце каждой строки

\n – служебный символ «перевод строки». Он и разделяет строки в файле: всё, что стоит до него, – одна строка, всё, что после, – следующая. В коде он записывается двумя знаками, а сам занимает один символ.

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

Лечится это снятием перевода строки:

line.strip() – убирает пробельные символы с обоих концов, и не только \n: пробелы и табуляцию тоже (урок 8.2);
line.rstrip('\n') – убирает только перевод строки и только справа: пробелы по краям остаются, а если \n нет, строка не меняется.

Разница между ними ровно одна: strip() чистит шире, rstrip('\n') – строго то, что просили.

# numbers.txt: 12, 7, 100 – по одному числу в строке

total = 0
with open('numbers.txt', encoding='utf-8') as f:
    for line in f:
        line = line.strip()        # снимаем перевод строки
        total = total + int(line)

print(total)                       # 119

Запись в файл

Чтение – половина работы. Вторая – сохранить полученное.

Записывает строку в файл метод write():

with open('result.txt', 'w', encoding='utf-8') as f:
    f.write('сумма: ')
    f.write(str(119))

write() не добавляет перевод строки. Записал строку – она легла вплотную к предыдущей. Нужна новая строка – поставьте \n сами: f.write(s + '\n'). Без этого две записи подряд дадут одну длинную строку.
write() ждёт строку. Число перед записью переводят в строку: f.write(str(119)), f.write('сумма: ' + str(total)). Вызов f.write(119) падает с TypeError: метод не догадывается, что число нужно превратить в текст.
write() возвращает число записанных символов – сколько символов легло в файл. Чаще всего возвращённое значение просто не смотрят, но иногда оно нужно: по нему видно, сколько ушло из строки.
Есть и второй способ печати в файл – print(..., file=f): он переводит значения в строку сам и добавляет перевод строки, как обычный print() на экране. Файл при этом обязан быть открыт на запись: в файл, открытый на чтение, и print(..., file=f), и write() падают с io.UnsupportedOperation: not writable.

Режим 'w' при этом работает как сказано выше: файл открыт на запись – старое содержимое стёрто ещё до первой строки. Если нужен не новый файл, а продолжение старого, режим другой.

total = 12 + 7 + 100

with open('result.txt', 'w', encoding='utf-8') as f:
    n = f.write('сумма: ' + str(total) + '\n')
    f.write('проверено\n')

print(n)        # 11 – столько символов записала первая строка:
#                 7 букв, 3 цифры и один перевод строки

# в result.txt теперь две строки:
#   сумма: 119
#   проверено
#
# каждый запуск начинается с пустого файла: режим 'w' стёр
# прошлый результат

Режим `'a'`: дописать, а не затереть

Режим 'w' стирает содержимое файла – это удобно, когда отчёт пишут заново, и губительно, когда записи копят. Для второго случая есть режим 'a' – от английского append, «дописать».

В режиме 'a' запись идёт в конец файла: старое содержимое остаётся на месте, а новое добавляется после него.

Файла нет – 'a' его создаст, как и 'w'. Файл есть – 'a' не тронет в нём ни символа и допишет новое в конец.

Так делают журналы – файлы, которые растут от запуска к запуску: программа работает раз в день и дописывает строку с результатом, а за месяц в файле набирается тридцать строк, и все на месте. В режиме 'w' после каждого запуска в файле оставалась бы ровно одна строка – последняя.

Разницу стоит проговорить: 'w' отвечает на вопрос «что должно быть в файле», 'a' – «что к нему добавить». Первый режим заменяет содержимое, второй накапливает.

# журнал: каждый запуск дописывает свою строку

total = 12 + 7 + 100

with open('journal.txt', 'a', encoding='utf-8') as f:
    f.write('сумма: ' + str(total) + '\n')

# перечитываем файл целиком
with open('journal.txt', encoding='utf-8') as f:
    print(f.read())

# первый запуск программы печатает одну строку:
#   сумма: 119
# второй – уже две, третий – три
# режим 'w' оставил бы в файле только последнюю

Где лежит файл

Короткое имя data.txt означает не «где-то на диске», а файл в рабочей папке программы – той, из которой программу запустили. Полный путь называют целиком: C:\Учёба\data.txt. Это может быть один и тот же файл – разница только в том, откуда программа его ищет.

Отсюда и самая частая причина FileNotFoundError: файл на диске есть, а программа ищет его не там. Что проверить, если чтение упало:

Лежит ли файл рядом с программой – то есть в той же папке, из которой она запущена.
Совпадает ли имя – до последнего символа. Windows по умолчанию прячет расширения, и файл data.txt в проводнике выглядит как data; созданный в блокноте документ легко превращается в data.txt.txt.
Не открыт ли файл другой программой – это уже не про FileNotFoundError, а про доступ, но проверяют это там же.

И полезная деталь о самих режимах: FileNotFoundError приходит в основном от чтения – режимы 'w' и 'a' отсутствующий файл не ищут, а создают. Поэтому опечатка в имени файла при записи не падает, а тихо заводит новый файл с неправильным именем, в то время как нужные данные лежат себе нетронутыми. Это ошибка, которую замечают не сразу.

Файл как вход задачи

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

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

with open('input.txt', encoding='utf-8') as f:
    s = f.read()

print(len(s))          # сколько всего символов
print(s[0], s[-1])     # первый и последний – индексы из урока 8.1
print(s.count('X'))    # сколько раз встретилась буква

Всё остальное – из уроков 8.1–8.3: len(s) даёт длину, s[i] – символ по индексу, срез – кусок строки, for c in s – проход по символам, а find(), count(), split() и strip() работают с прочитанным точно так же, как с любой строкой в переменной. Именно так устроены задачи, где на вход дают текстовый файл на сотни тысяч символов: read() приносит содержимое, а дальше начинается обычная работа со строкой.

Одна оговорка о размере. read() держит в памяти весь файл сразу: миллион символов – это 1–2 Мбайт, и это нормально, а вот гигабайтный файл так читать не стоит. Если данные в файле построчные и нужна только сумма или счётчик, читают циклом for line in f – тогда в памяти живёт одна строка за раз, сколько бы их ни было в файле.

Шпаргалка

Что	Что делает
`open(путь, 'r', encoding='utf-8')`	открывает файл на чтение; режим по умолчанию, его обычно не пишут
`open(путь, 'w', encoding='utf-8')`	открывает на запись: файла нет – создаст, файл есть – сотрёт содержимое сразу при открытии
`open(путь, 'a', encoding='utf-8')`	открывает на дописывание: файла нет – создаст, файл есть – оставит содержимое и допишет в конец
`with open(...) as f:`	закрывает файл сам в конце блока, даже если внутри случилась ошибка
`f.read()`	весь файл одной строкой, вместе с `\n` внутри
`f.readline()`	одну строку, вместе с `\n` на конце
`f.readlines()`	список всех строк (что это – блок 9)
`for line in f:`	по строке за раз; годится для файла любого размера
`f.write(s)`	записывает строку с текущей позиции, перевода строки не добавляет, возвращает число записанных символов
`print(..., file=f)`	печатает в файл, переводя значения в строку и добавляя `\n`
`f.close()`	закрывает файл; при `with` не нужен

Коротко

Файл – данные на диске, у которых есть имя. Они переживают запуск программы, поэтому в файл кладут то, что должно остаться, и то, что слишком велико для ввода с клавиатуры.
Открывают файл функцией open(путь, режим, encoding='utf-8'), и encoding='utf-8' указывают всегда: без него Python берёт кодировку системы, а на Windows это не UTF-8 – русский текст превращается в мусор или падает с UnicodeDecodeError.
Режимы: 'r' – чтение (по умолчанию, файла нет – FileNotFoundError), 'w' – запись (создаёт и стирает содержимое сразу при открытии), 'a' – дописывание в конец.
with open(...) as f: закрывает файл сам – и при нормальном выходе, и после ошибки. Пока файл не закрыт, записанное лежит в буфере: программа, открывшая тот же файл на чтение раньше времени, увидит пустоту.
Каждая прочитанная строка приходит с \n на конце, кроме возможно последней. Поэтому int(line) работает, а line == 'да' – нет: перед сравнением строку чистят strip() или rstrip('\n').
f.write() пишет строку и не добавляет перевод строки (его ставят сами), число перед записью переводят через str(), а возвращает write() число записанных символов.

О чём этот урок

Файл глазами программы

open(): три вещи в одной строке

with: файл закрывается сам