Python 3. Работа с файлами

Работа с текстовыми файлами в Python 3 на простых примерах. Узнаете, как открывать, читать и записывать файлы, безопасно закрывать их через with, сохранять строки, списки и словари в txt, JSON и pickle.

Что такое файлы в 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 .