Python 3. Работа с файлами
Что такое файлы в Python
В Python файл — это объект, через который программа читает данные с диска или записывает их на диск. Строки, списки, числа и словари живут в оперативной памяти и пропадают после завершения программы. Чтобы данные сохранились, их нужно записать в файл.
Создать объект файла можно с помощью встроенной функции open(). У этого объекта есть методы для работы с содержимым: одни записывают данные в файл, другие читают их из него.
В этой статье мы будем работать с текстовыми файлами. Содержимое такого файла Python воспринимает как строки. Файлы буферизируются (Python не пишет на диск каждый символ отдельно, а накапливает данные и записывает их порциями) и поддерживают позиционирование: у файла есть текущая позиция, и мы можем её менять.
Функция open() и режимы доступа
Для открытия файла служит функция open(). Ей передают путь к файлу и режим доступа:
open('myfile.txt', 'r', encoding='utf-8')
Режим доступа определяет, что мы сможем делать с файлом. Вот основные режимы:
r— только чтение. Это режим по умолчанию. Если файла нет, будет ошибка;w— только запись. Если файла нет, он создаётся. Если файл есть, его содержимое стирается;a— запись в конец файла (дозапись). Если файла нет, он создаётся, а старое содержимое сохраняется;x— создание нового файла для записи. Если файл уже есть, будет ошибка;r+— чтение и запись. Файл должен существовать, при открытии он не стирается;w+— чтение и запись. Если файла нет, он создаётся, а если есть, то стирается.
К режиму можно добавить букву b (например, rb или wb), тогда файл открывается как бинарный, то есть мы работаем не со строками, а с байтами. Буква t (текстовый режим) подразумевается по умолчанию.
Будьте внимательны с режимами w и w+: открыв существующий файл в таком режиме, вы потеряете всё, что в нём было.
Второй важный параметр — encoding. Он указывает кодировку файла. Сегодня почти везде используется utf-8, и я рекомендую всегда указывать её явно. Если не указать, Python возьмёт кодировку, принятую в системе, а она может отличаться, например, в Windows. Тогда русский текст, записанный на одном компьютере, на другом может превратиться в «кракозябры».
Открытие и закрытие файла
Когда мы открываем файл, операционная система выделяет под него ресурсы. После работы файл нужно закрыть, чтобы освободить эти ресурсы и убедиться, что все данные дошли до диска. Для этого есть метод close().
Вот пример. Мы запишем в файл две строки, а затем прочитаем их:
Код:
myfile = open('myfile.txt', 'w', encoding='utf-8') # Открыли файл на запись
myfile.write('Привет Мир!\n') # Записали первую строку
myfile.write('Всем привет!\n') # Записали вторую строку
myfile.close() # Закрыли файл
myfile = open('myfile.txt', 'r', encoding='utf-8') # Открыли файл на чтение
print(myfile.readline()) # Прочитали первую строку
print(myfile.readline()) # Прочитали вторую строку
myfile.close() # Закрыли файл
Исполнение:
Привет Мир!
Всем привет!
Между строками появились пустые строки. Дело в том, что в конце каждой строки файла стоит символ \n (переход на новую строку), а print() добавляет к выводу ещё один такой же символ. Как с этим бороться, расскажу чуть ниже.
Закрывать файл желательно всегда через close(). Без этого, файл должен закрыться когда Python удалит объект из памяти. Полагаться на это не стоит: когда это произойдёт, зависит от реализации интерпретатора, а при ошибке в программе файл может остаться незакрытым, и часть данных не будет записана.
Оператор with
Правильный способ работы с файлами — оператор with. Он автоматически закрывает файл, когда мы выходим из блока, даже если внутри произошла ошибка:
Код:
with open('myfile.txt', 'r', encoding='utf-8') as myfile:
print(myfile.read())
Исполнение:
Привет Мир!
Всем привет!
Всё, что мы делаем с файлом, пишется с отступом внутри блока with. Как только отступ закончился, файл закрыт. Метод close() вызывать не нужно. Дальше в статье я буду везде использовать with.
Методы для работы с файлами
В примерах выше мы уже использовали несколько методов. Вот основные из них:
write(str)— записывает строку в файл;read(n)— читает файл целиком, а если указать числоn, то читаетnсимволов;readline()— читает одну строку, начиная с текущей позиции;readlines()— читает весь файл и возвращает список строк;seek(n)— перемещает текущую позицию в файле. Чаще всего используютseek(0), чтобы вернуться в начало файла;close()— закрывает файл.
Посмотрим, как работает чтение по частям. Текущая позиция сдвигается вместе с чтением: каждое следующее чтение продолжается с того места, где закончилось предыдущее.
Код:
with open('myfile.txt', 'r', encoding='utf-8') as myfile:
print(repr(myfile.read(6))) # Первые 6 символов
print(repr(myfile.read(6))) # Следующие 6 символов
myfile.seek(0) # Вернулись в начало файла
print(myfile.readlines()) # Весь файл как список строк
Исполнение:
'Привет'
' Мир!\n'
['Привет Мир!\n', 'Всем привет!\n']
Здесь я использовал функцию repr(), чтобы увидеть символы перехода на новую строку (\n), которые обычный print() превращает в настоящий перенос.
Построчное чтение файла
Файл можно обрабатывать построчно, просто пробежавшись по нему циклом for. Это самый удобный и экономный способ: Python читает по одной строке и не загружает в память весь файл. Для больших файлов это важно.
Код:
with open('myfile.txt', 'r', encoding='utf-8') as myfile:
for line in myfile:
print(line, end='')
Исполнение:
Привет Мир!
Всем привет!
Здесь цикл for по очереди берёт строки файла и выводит их. Так как каждая строка оканчивается на \n, я указываю end='', чтобы print() не добавлял ещё один перенос. Другой вариант — убрать \n из строки методом rstrip(): print(line.rstrip()).
Дозапись в файл
Если открыть файл в режиме w, старое содержимое будет стёрто. Чтобы добавить данные в конец файла, используйте режим a:
Код:
with open('myfile.txt', 'a', encoding='utf-8') as myfile:
myfile.write('Третья строка\n')
with open('myfile.txt', 'r', encoding='utf-8') as myfile:
print(myfile.read(), end='')
Исполнение:
Привет Мир!
Всем привет!
Третья строка
Сохранение объектов в текстовый файл
В файл можно записывать только строки. Поэтому, чтобы сохранить число, список или словарь, их сначала нужно превратить в строку. Давайте сохраним несколько разных объектов:
Код:
a, b, c = 43, 23, 45
mytext = 'Test'
mydict = {'a': 1, 'b': 2}
mylist = [1, 2, 3]
with open('datafile.txt', 'w', encoding='utf-8') as myfile:
# Первая строка — обычный текст
myfile.write(mytext + '\n')
# Вторая строка — числа через запятую (f-строка сама превращает их в текст)
myfile.write(f'{a},{b},{c}\n')
# Третья строка — список и словарь, превращённые в строки функцией str()
# Между ними ставим разделитель '$'
myfile.write(str(mylist) + '$' + str(mydict))
# Проверим, что получилось
with open('datafile.txt', 'r', encoding='utf-8') as myfile:
print(myfile.read())
Исполнение:
Test
43,23,45
[1, 2, 3]${'a': 1, 'b': 2}
Для подстановки значений в строку я использую f-строки (f'{a},{b},{c}\n'). Это современный и самый читаемый способ форматирования. В старых статьях можно встретить '%s,%s,%s\n' % (a, b, c), он тоже работает, но сегодня используется реже.
Считывание объектов из текстового файла
Теперь прочитаем эти данные обратно. Мы читаем строки и превращаем их в нужные объекты:
Код:
with open('datafile.txt', 'r', encoding='utf-8') as myfile:
# Первая строка — текст. rstrip() убирает символ конца строки
mytext = myfile.readline().rstrip()
print(mytext)
# Вторая строка — числа. Разбиваем по запятым и преобразуем каждое в int
my_numbers = [int(it) for it in myfile.readline().split(',')]
print(my_numbers)
# Третья строка — список и словарь. Разбиваем по разделителю '$'
my_list, my_dict = myfile.readline().split('$')
print(my_list)
print(my_dict)
print(type(my_list))
Исполнение:
Test
[43, 23, 45]
[1, 2, 3]
{'a': 1, 'b': 2}
<class 'str'>
Обратите внимание на последнюю строку вывода. Переменная my_list выглядит как список, но на самом деле это строка '[1, 2, 3]'. Мы получили текст, а не объект. Чтобы вернуть настоящий список, строку нужно разобрать. Для этого подойдёт функция literal_eval() из модуля ast. Она безопасно превращает строку с литералом Python в объект:
Код:
import ast
print(ast.literal_eval('[1, 2, 3]'))
print(type(ast.literal_eval('[1, 2, 3]')))
Исполнение:
[1, 2, 3]
<class 'list'>
Такой способ работает, но он неудобен: нужно самому придумывать формат файла, разделители и правила разбора. К счастью, для хранения данных есть готовые форматы. Рассмотрим два из них.
Сохранение объектов в JSON
JSON — самый популярный текстовый формат для хранения и обмена данными. Он понятен человеку, его можно открыть в любом редакторе, и с ним умеют работать практически все языки программирования. В Python для него есть модуль json, он входит в стандартную библиотеку.
Сохраним те же данные в JSON:
Код:
import json
data = {
'text': 'Test',
'numbers': [43, 23, 45],
'mylist': [1, 2, 3],
'mydict': {'a': 1, 'b': 2},
}
with open('datafile.json', 'w', encoding='utf-8') as myfile:
json.dump(data, myfile, ensure_ascii=False, indent=4)
with open('datafile.json', 'r', encoding='utf-8') as myfile:
print(myfile.read())
Исполнение:
{
"text": "Test",
"numbers": [
43,
23,
45
],
"mylist": [
1,
2,
3
],
"mydict": {
"a": 1,
"b": 2
}
}
Функция json.dump() записывает объект в файл. Два необязательных параметра делают файл удобнее:
indent=4— расставляет отступы, чтобы файл было удобно читать;ensure_ascii=False— сохраняет русские буквы как есть. Без него они превратятся в последовательности видаП.
Теперь считаем данные обратно функцией json.load():
Код:
import json
with open('datafile.json', 'r', encoding='utf-8') as myfile:
data = json.load(myfile)
print(data)
print(data['mydict']['a'])
Исполнение:
{'text': 'Test', 'numbers': [43, 23, 45], 'mylist': [1, 2, 3], 'mydict': {'a': 1, 'b': 2}}
1
На этот раз мы сразу получили настоящие списки и словари, а не строки. JSON хранит только базовые типы: строки, числа, списки, словари, True, False и None. Для настроек, конфигураций и обмена данными с другими программами этого обычно хватает.
Запись и считывание объектов бинарно (pickle)
Если нужно сохранить объект Python как есть, не превращая его в строки, можно использовать модуль pickle. В отличие от JSON, он умеет сохранять почти любые объекты Python, в том числе собственные классы. Файл при этом бинарный, поэтому открываем его в режимах wb и rb.
Код:
import pickle
mydict = {'a': 1, 'b': 2}
# Запись в файл
with open('datafile.pkl', 'wb') as myfile:
pickle.dump(mydict, myfile)
# Считывание из файла
with open('datafile.pkl', 'rb') as myfile:
mydict = pickle.load(myfile)
print(mydict)
Исполнение:
{'a': 1, 'b': 2}
Обратите внимание, что кодировку (encoding) для бинарных файлов указывать не нужно: мы работаем с байтами, а не с текстом.
Модуль pickle небезопасен. Никогда не загружайте через pickle.load() файлы из недоверенных источников: при распаковке такой файл может выполнить произвольный код на вашем компьютере. Для обмена данными лучше использовать JSON, а pickle оставить для своих временных данных, например для кэша.
Модуль pathlib
В современном Python для работы с путями и файлами часто используют модуль pathlib. С его помощью простые операции делаются в одну строку:
Код:
from pathlib import Path
p = Path('notes.txt')
p.write_text('Заметка\nВторая строка\n', encoding='utf-8') # Записать текст в файл
print(p.read_text(encoding='utf-8'), end='') # Прочитать файл целиком
print(p.exists()) # Проверить, существует ли файл
Исполнение:
Заметка
Вторая строка
True
Методы write_text() и read_text() сами открывают и закрывают файл, поэтому with здесь не нужен. Они удобны, когда файл небольшой и его нужно обработать целиком.
Обработка ошибок
При работе с файлами многое может пойти не так: файла нет, нет прав на запись, диск заполнен. Самые частые ошибки — FileNotFoundError (файл не найден) и FileExistsError (файл уже существует, например, при режиме x). Их можно перехватить с помощью try и except:
Код:
try:
with open('no_such_file.txt', 'r', encoding='utf-8') as myfile:
print(myfile.read())
except FileNotFoundError:
print('Файл не найден')
try:
with open('myfile.txt', 'x', encoding='utf-8') as myfile:
pass
except FileExistsError as e:
print(e)
Исполнение:
Файл не найден
[Errno 17] File exists: 'myfile.txt'
Итог
Мы разобрали основы работы с текстовыми файлами в Python 3:
- открывать файл нужно функцией
open(), указывая режим доступа и кодировкуutf-8; - режимы
wиw+стирают содержимое файла, а для дозаписи используетсяa; - работать с файлами лучше через оператор
with, он сам закроет файл; - читать файл можно целиком (
read()), по строкам (readline()), списком строк (readlines()) или цикломfor, последний вариант самый экономный; - в текстовый файл можно записать только строки, поэтому остальные объекты нужно преобразовывать;
- для хранения списков и словарей удобнее использовать формат JSON, а модуль
pickleсохраняет объекты бинарно, но его небезопасно применять к чужим файлам.
В этой статье мы использовали основные типы данных: строки, списки, словари и другие. Про некоторые из них можете почитать в этой статье .
Если понравилась статья, подпишись на мой канал в VK или Telegram .