Функция open() в Python. Чтение и запись файлов
Большие объемы данных хранят не в списках или словарях, а в файлах и базах данных. В этом уроке изучим особенности работы с текстовыми файлами в Python. Такие файлы рассматриваются как содержащие символы и строки.
Бывают еще байтовые (бинарные) файлы, которые рассматриваются как потоки байтов. По байтам считываются, например, файлы изображений. Работа с бинарными файлами несколько сложнее. Нередко их обрабатывают с помощью специальных модулей Python (pickle, struct).
Функция open
Связь с файлом на жестком диске выполняется с помощью встроенной в Python функции open() . Обычно ей передают один или два аргумента. Первый – имя файла или имя с адресом, если файл находится не в том каталоге, где находится сама программа. Второй аргумент – режим, в котором открывается файл.
Обычно используются режимы чтения ( ‘r’ ) и записи ( ‘w’ ). Если файл открыт в режиме чтения, то запись в него невозможна. Можно только считывать данные. Если файл открыт в режиме записи, то в него можно только записывать данные, считывать нельзя.
Если файл открывается в режиме ‘w’ , то все данные, которые в нем были до этого, стираются. Файл становится пустым. Если не надо удалять существующие в файле данные, тогда следует использовать вместо режима записи, режим дозаписи ( ‘a’ ).
Если файл отсутствует, то открытие его в режиме ‘w’ создаст новый файл. Бывают ситуации, когда надо гарантировано создать новый файл, избежав случайной перезаписи данных существующего. В этом случае вместо режима ‘w’ используется режим ‘x’ . В нем всегда создается новый файл для записи. Если указано имя существующего файла, то будет выброшено исключение. Потери данных в уже имеющемся файле не произойдет.
Если при вызове open() второй аргумент не указан, то файл открывается в режиме чтения как текстовый файл. Чтобы открыть файл как байтовый, дополнительно к букве режима чтения/записи добавляется символ ‘b’ . Буква ‘t’ обозначает текстовый файл. Поскольку это тип файла по умолчанию, то обычно ее не указывают.
Нельзя указывать только тип файла, то есть open(«имя_файла», ‘b’) есть ошибка, даже если файл открывается на чтение. Правильно – open(«имя_файла», ‘rb’) . Только текстовые файлы мы можем открыть командой open(«имя_файла») , потому что и ‘r’ и ‘t’ подразумеваются по-умолчанию.
Функция open() возвращает объект файлового типа. Его надо либо сразу связать с переменной, чтобы не потерять, либо сразу прочитать.
Чтение файла
С помощью файлового метода read() можно прочитать файл целиком или только определенное количество байт. Пусть у нас имеется файл data.txt с таким содержимым:
one - 1 - I two - 2 - II three - 3 - III four - 4 - IV five - 5 - V
Откроем его и почитаем:
>>> f1 = open(‘data.txt’) >>> f1.read(10) ‘one — 1 — ‘ >>> f1.read() ‘I\ntwo — 2 — II\nthree — 3 — III\nfour — 4 — IV\nfive — 5 — V\n’ >>> f1.read() » >>> type(f1.read())
Сначала считываются первые десять символов. Последующий вызов read() считывает весь оставшийся текст. После этого объект файлового типа f1 становится пустым.
Заметим, что метод read() возвращает строку.
Для того чтобы читать файл построчно, существует метод readline() :
>>> f1 = open('data.txt') >>> f1.readline() 'one - 1 - I\n' >>> f1.readline() 'two - 2 - II\n' >>> f1.readline() 'three - 3 — III\n'
Метод readlines() считывает сразу все строки и создает список:
>>> f1 = open('data.txt') >>> f1.readlines() ['one - 1 - I\n', 'two - 2 - II\n', 'three - 3 - III\n', 'four - 4 - IV\n', 'five - 5 - V\n']
Объект файлового типа относится к итераторам. Из таких объектов происходит последовательное извлечение элементов. Элементами в данном случае являются строки-линии файла. Поэтому считывать данные из файла можно сразу в цикле без использования методов чтения:
>>> for i in open('data.txt'): . print(i) . one - 1 - I two - 2 - II three - 3 - III four - 4 - IV five - 5 - V >>>
Здесь выводятся лишние пустые строки, потому что функция print() преобразует ‘\n’ в переход на новую строку. К этому добавляет свой переход на новую строку. Создадим список строк файла без ‘\n’ :
>>> nums = [] >>> for i in open('data.txt'): . nums.append(i[:-1]) . >>> nums ['one - 1 - I', 'two - 2 - II', 'three - 3 - III', 'four - 4 - IV', 'five - 5 - V']
Переменной i присваивается очередная строка файла. Мы берем ее срез от начала до последнего символа, не включая его. Следует иметь в виду, что ‘\n’ это один символ, а не два.
Запись в файл
Запись в файл выполняется с помощью методов write() и writelines() . Во второй можно передать структуру данных:
>>> l = ['three', 'four'] >>> f2 = open('newdata.txt', 'w') >>> f2.write('one') 3 >>> f2.write(' two') 4 >>> f2.writelines(l)
Метод write() возвращает количество записанных символов.
Закрытие файла
После того как работа с файлом закончена, важно не забывать его закрыть, чтобы освободить место в памяти. Делается это с помощью файлового метода close() . Свойство файлового объекта closed позволяет проверить закрыт ли файл.
>>> f1.close() >>> f1.closed True >>> f2.closed False
Если файл открывается в заголовке цикла ( for i in open(‘fname’) ), он автоматически не закрывается при завершении работы цикла, а остается открытым на неопределенное количество времени. Поэтому в больших программах лучше так не делать. Если файл открывается для одномоментного чтения или записи, и вы не хотите захламлять код строчками кода его открытия и закрытия, то следует использовать оператор with . Он отслеживает, чтобы при выходе из его тела файл был закрыт. Пример использования:
>>> with open('test.txt') as f: . for line in f: . print(line, end='') . one two three four
Практическая работа
- Создайте файл data.txt по образцу урока. Напишите программу, которая открывает этот файл на чтение, построчно считывает из него данные и записывает строки в другой файл ( dataRu.txt ), заменяя английские числительные русскими, которые содержатся в списке ( [«один», «два», «три», «четыре», «пять»] ), определенном до открытия файлов.
- Создайте файл nums.txt , содержащий несколько чисел, записанных через пробел. Напишите программу, которая подсчитывает и выводит на экран общую сумму чисел, хранящихся в этом файле.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
Типизированные файлы в Паскаль
Более характерным для Pascal являются типизированные файлы, или файлы произвольного доступа. Основным свойством этих файлов является то, что их структура данных представляет собой последовательность компонентов одного типа.
При описании типизированных файлов указывается тип его компонентов, число которых (длина файла) не фиксируется:
var имя_файла: file of тип_компонентов
Поскольку известен тип элементов файла, а следовательно, и объем памяти, отводимой под каждый из них, можно рассчитать позицию каждого из элементов внутри файла. Это позволяет организовать непосредственный доступ к любому элементу типизированного файла. Пусть имеется такое определение переменной:
var FileInt: file of Integer;В этом описании указано, что элементами файла являются данные типа Integer , занимающие 2 байта (или 4). При этом отпадает необходимость в специальном разделении элементов файла, как это делалось в текстовых файлах. Также возможен произвольный доступ к элементам данных (этим типизированный файл несколько напоминает одномерный массив).
Чтобы можно было работать с типизированным файлом, необходимо, как и для текстовых файлов, сначала связать имя файловой переменной с внешним именем файла (оператор assign ). Затем нужно открыть его (используются операторы reset или rewrite ).
Операторы reset и rewrite открывают файл и для чтения, и для записи (а не только для чтения или только для записи, как при использовании текстовых файлов). Отличие их в том, что оператор reset открывает только существующий файл (если такого файла нет, будет сгенерирована ошибка времени выполнения). С другой стороны, оператор rewrite создает новый файл (если файл с таким именем уже имеется, то он будет уничтожен и создан заново).
При открытии файла с ним связывается текущий указатель файла, который позиционируется на его первый элемент. Оперировать можно только тем элементом файла, на который ссылается указатель файла. При чтении или записи элемента файла происходит автоматическое перемещение указателя на следующий элемент.
Чтение из типизированного файла производится оператором read (но не readln ), а запись в него — оператором write (но не writeln ). Однако следует помнить, что в списке вывода оператора write могут быть только переменные. Типы элементов файла и типы переменных в списках ввода-вывода должны быть согласуемы по присваиванию. Элементами типизированных файлов могут быть числовые, символьные, булевы, строковые значения, массивы, записи, но не файлы или структуры с файловыми элементами.
Узнать количество элементов типизированного файла (размер файла) можно с помощью функции FileSize , для которой используется следующий синтаксис:
Например, если переменная k имеет тип LongInt , а f – файловая переменная типизированного файла, то выражение k := FileSize(f) , записывает в переменную k размер файла f .
Элементы типизированного файла нумеруются с нуля (порядковый номер последнего элемента файла на единицу меньше размера файла). Чтобы узнать, на каком элементе располагается указатель файла, используют функцию FilePos :
FilePos(имя_файла)Текущим положением указателя можно управлять, для чего служит процедура Seek , которая использует следующий синтаксис:
Seek(имя_файла, номер_элемента)Второй параметр (тип LongInt ) задает номер элемента (отсчет от 0), на который должен переместиться указатель файла. Рассмотрим несколько примеров.
Перейти к пятому (фактически шестому) элементу файла f :
Seek(f, 5);Перейти к предыдущему элементу:
Seek(f, FilePos(f)-1);Перейти в конец файла:
Seek(f, FileSize(f)-1);Как и для текстовых файлов, можно использовать функцию Eof(имя_файла) , которая возвращает значение True , если текущий указатель расположен на признаке конца файла (то есть при выполнения равенства FilePos(имя_файла) = FileSize(имя_файла) ).
Процедура seek и функции FilePos и FileSize позволяют легко осуществлять коррекцию элементов типизированного файла, имя которого указано в качестве е параметра, начиная с элемента, на котором расположен указатель. Однако уничтожить элемент внутри файла нельзя, для этого файл должен быть перезаписан.
Текстовые файлы могут быть созданы текстовым редактором. Однако типизированные файлы создаются в результате работы какой-либо программы.
Пример записи данных в типизированный файл:
type t_subscriber = record surname: string[20]; tel: LongInt; end; var subscriber: t_subscriber; f: file of t_subscriber; i: Integer; begin Assign(f,'notebook.dat'); Rewrite(f); for i:=1 to 5 do begin with subscriber do begin Write('Surname: '); ReadLn(surname); Write('Phone: '); ReadLn(tel); end; Write(f, subscriber); end; Close(f); end.Пример последовательного доступа к типизированному файлу:
type t_subscriber = record surname: string[20]; tel: LongInt; end; var subscriber: t_subscriber; f: file of t_subscriber; s: string[7]; begin Assign(f,'notebook.dat'); Reset(f); while not Eof(f) do begin Read(f, subscriber); with subscriber do begin str(tel,s); if Copy(s,1,2) = '33' then tel := tel+4000000; end; Seek(f,FilePos(f)-1); // возврат указателя назад Write(f,subscriber); end; Close(f); end. В приведенной программе типизированный файл обрабатывается и как файл последовательного доступа, и как файл произвольного доступа.
Ввод-вывод, оператор присваивания, арифметические операции
Теоретический материал: файловый ввод-вывод (Паскаль)
Файлы. Виды файлов. Основные процедуры для работы с файлами
До сих пор мы рассматривали задачи, в которых во время выполнения программы данные поступают с клавиатуры, а результаты выводятся на экран дисплея. При этом ни исходные данные, ни результаты не сохраняются. Всякий раз при выполнении одной и той же программы, в частности, во время отладки, приходится заново вводить данные. А если их очень много? В языке Паскаль есть возможность записать их на диск. Для этого необходимо оформить исходные данные и результаты в виде файлов, которые хранятся на диске точно так же, как и программы.
Понятие файла — это фундаментальное понятие информатики, вспомним же его определение.
Определение. Файлом называется область памяти на диске, имеющая свое имя.
Вы знаете различные виды физических файлов: системные, графические, текстовые и другие, зачастую созданные той или иной прикладной программой. И любой из этих физических файлов Вы сможете считать, проанализировать, изменить и записать.
Физические файлы можно по-разному представить в программе. Язык Турбо Паскаль предлагает три вида представления файлов:
И Вы, в зависимости от решаемой задачи, вольны выбирать один их трех видов, а, может быть, и несколько. Для того, чтобы сделать правильный выбор, Вы должны хорошо знать не только процедуры и функции, являющиеся общими для всех видов файлов, но и специфичные для каждого вида.
Для работы с конкретным физическим файлом на диске надо представить в программе так называемую файловую переменную и произвести ее логическую связку с этим файлом. Файловые переменные имеют специфическое применение. Над ними нельзя выполнять никаких операций (присваивать значение, сравнивать и др.). Их можно использовать только для выполнения операций с файлами (чтения, записи, удаления файла и т.д.). Кроме того, через файловую переменную можно получить информацию о конкретном файле (тип, параметры, имя файла и т.д.).
По сути, любой физический файл можно представить как последовательность блоков информации некоторого типа. Все компоненты файла имеют общее имя, а каждый имеет еще и свой номер. Начальный элемент имеет нулевой номер.
Количество элементов файла может быть любым: число компонентов файла может изменяться (увеличиваться или уменьшаться), то есть, заранее не фиксируется. В файлах можно хранить достаточно большое количество данных. После каждого элемента файла автоматически ставится признак конца элемента, а в конце файла ставится признак конца файла.
С каждым файлом можно связать понятие «текущий указатель». Это неявно описанная переменная, которая указывает на конкретный элемент файла. Действия с файлами производятся поэлементно, причем в них участвует тот элемент, на который «смотрит» текущий указатель, перемещающийся в результате выполнения действия на следующий элемент.
Главное, чему необходимо научиться при работе с файлами — это записать информацию из программы в файл и считать нужную информацию в выделенную переменную для обработки программой. Общая последовательность действий при этом такова:
— описать переменную файлового типа;
— связать ее с конкретным физическим файлом процедурой assign;
— открыть файл процедурой reset или rewrite;
— выполнить чтение или запись информации;
— по окончании работы с файлом закрыть файл процедурой close.
Формат объявления файловых переменных и особенности работы с различными видами файлов (типизированными, нетипизированными, текстовыми) будут подробно изложены далее.
Процедуры и функции для работы с файлами любого типа
Переменные файлового типа используются в программе только в качестве параметров собственных и стандартных процедур и функций. Все фактические действия с файлами основаны на наборе стандартных процедур языка, входящих в состав модулей System и Dos.
Сначала рассмотрим процедуры модуля System.
Напомним, что он подключен к программам по умолчанию, то есть его не требуется подключать к программе в разделе Uses.
До начала работы с файлами устанавливается связь файловой переменной МуFilе с именем дискового файла. Очень важно различать собственно файл (область памяти на магнитном носителе с некоторой информацией) и переменную файлового типа в Turbo Pascal-программе. Считается, что файловая переменная является представителем некоторого дискового файла в программе. Для того, чтобы реализовать доступ к файлу на магнитном диске, программа должна связать его с файловой переменной. Для этого необходимо установить соответствие между переменной и именем файла. Это имя представляется в виде строки, содержащей имя файла и, может быть, путь к файлу, который формируется по общим правилам MS-DOS.
| assign (МуFilе, ‘с:\МуDirectory\Result.dat’); |
здесь приведено полное (с указанием пути) имя пользовательского файла Result.dat.
Если путь не указан, программа будет искать файл только в своем рабочем каталоге и, как это принято в системе DOS, по указанным в файле аutoехес.bat путям. Кроме указания имени файла на дисковом накопителе может быть указано стандартное имя одного из устройств ввода-вывода: «соn» — консоль, то есть дисплей и клавиатура, «рrn» — или «lpt1» — принтер.
Не разрешается связывать с одним физическим файлом разные файловые переменные программы.
До тех пор, пока файловая переменная не связана с каким-либо дисковым файлом, никакие операции с ней в программе невозможны. Заметим, что можно связать файловую переменную с еще не существующим дисковым файлом. Это делается в случае последующего создания Turbo Pascal-программой файла с данным именем с помощью специальной системной процедуры.
После того, как файловая переменная с помощью процедуры Аssign связана с конкретным дисковым файлом, с ним можно выполнить любую допустимую операцию.
Внимание! Нельзя применять процедуру assign к открытому файлу.
Все файлы, открытые в результате работы программы, должны быть закрыты при завершении программы процедурой
| closе (МуFilе); |
При выполнении этого оператора закрывается физический файл на диске, и фиксируются изменения, связанные с использованием данного файла. Обратите внимание на необходимость закрытия файлов во всех ветвях программы, в том числе в различных аварийных ситуациях. Незакрытые файлы нарушают файловую структуру на диске, что может приводить к серьезным проблемам с настройкой компьютера.
Открытие нового файла производится процедурой, единственный аргумент которой — переменная файлового типа, например:
| rewrite (МуFilе); |
Эта процедура создает на диске файл с именем, связанным с переменной МуFilе процедурой Аssign. Указатель работы с файлом устанавливается на начало файла. После выполнения процедуры rewrite файл доступен как для записи, так и для чтения (в случае текстовых файлов – только для записи).
Внимание! Если файл с таким именем уже существует, он удаляется (его содержимое теряется), и создается новый пустой файл с данным именем.
Открытие существующего файла выполняет процедура
| reset (МуFilе); |
Эта процедура ищет уже существующий файл на диске и открывает его для работы, помещая указатель в начальную позицию. Если файл с установленным в Аssign именем не найден, возникает ошибка ввода/вывода, контроль которой зависит от директивы компилятора (смотрите здесь). После выполнения процедуры reset файл доступен как для записи, так и для чтения (в случае текстовых файлов – только для чтения).
Запись в файл производится процедурой
| write (МуFilе, var1, var2, . varN); |
Первый аргумент этой процедуры — переменная файлового типа, далее следует список записываемых переменных, которые должны соответствовать объявленному типу файла. При выполнении этой операции текущий указатель файла смещается на число позиций, равное числу переменных.
Чтение из файла производится аналогичной процедурой:
| read (МуFilе, var1, var2, . varN); |
Примечание. Особенности выполнения операций записи и чтения для нетипизированных и текстовых файлов описаны в соответствующих разделах.
Положение элементов в файле нумеруется, начиная с номера 0 для первого элемента. После последнего элемента файла автоматически записывается признак конца файла.
Функция FileSize(МуFilе) определяет число элементов в файле. Функция неприменима к текстовым файлам. Файл MyFyle должен быть открыт.
Функция логического типа ЕОF(МуFilе) имеет значение Тruе, если указатель указывает на маркер конца файла (End Of File).
При помощи какого оператора текстовый файл открывается для перезаписи
Для работы с файлами в стандартной библиотеке определен заголовочный файл fstream , который определяет базовые типы для чтения и записи файлов. В частности, это:
- ifstream : для чтения с файла
- ofstream : для записи в файл
- fstream : совмещает запись и чтение
Для работы с данными типа wchar_t для этих потоков определены двойники:
- wifstream
- wofstream
- wfstream
Открытие файла
При операциях с файлом вначале необходимо открыть файл с помощью функции open() . Данная функция имеет две версии:
- open(путь)
- open(путь, режим)
Для открытия файла в функцию необходимо передать путь к файлу в виде строки. И также можно указать режим открытия. Список доступных режимов открытия файла:
- ios::in : файл открывается для ввода (чтения). Может быть установлен только для объекта ifstream или fstream
- ios::out : файл открывается для вывода (записи). При этом старые данные удаляются. Может быть установлен только для объекта ofstream или fstream
- ios::app : файл открывается для дозаписи. Старые данные не удаляются.
- ios::ate : после открытия файла перемещает указатель в конец файла
- ios::trunc : файл усекается при открытии. Может быть установлен, если также установлен режим out
- ios::binary : файл открывается в бинарном режиме
Если при открытии режим не указан, то по умолчанию для объектов ofstream применяется режим ios::out , а для объектов ifstream — режим ios::in . Для объектов fstream совмещаются режимы ios::out и ios::in .
std::ofstream out; // поток для записи out.open("hello1.txt"); // окрываем файл для записи std::ofstream out2; out2.open("hello2.txt", std::ios::app); // окрываем файл для дозаписи std::ofstream out3; out2.open("hello3.txt", std::ios::out | std::ios::trunc); // установка нескольких режимов std::ifstream in; // поток для чтения in.open("hello4.txt"); // окрываем файл для чтения std::fstream fs; // поток для чтения-записи fs.open("hello5.txt"); // окрываем файл для чтения-записи
Однако в принципе необязательно использовать функцию open для открытия файла. В качестве альтернативы можно также использовать конструктор объектов-потоков и передавать в них путь к файлу и режим открытия:
fstream(путь) fstream(путь, режим)
При вызове конструктора, в который передан путь к файлу, данный файл будет автоматически открываться:
std::ofstream out("hello.txt"); std::ifstream in("hello.txt"); std::fstream fs("hello.txt", std::ios::app);
В данном случае предполагается, что файл «hello.txt» располагается в той же папке, где и файл программы.
Вообще использование конструкторов для открытия потока является более предпочтительным, так как определение переменной, представляющей файловой поток, уже преполагает, что этот поток будет открыт для чтения или записи. А использование конструктора избавит от ситуации, когда мы забудем открыть поток, но при этом начнем его использовать.
В процессе работы мы можем проверить, окрыт ли файл с помощью функции is_open() . Если файл открыт, то она возвращает true:
std::ifstream in; // поток для чтения in.open(«hello.txt»); // окрываем файл для чтения // если файл открыт if (in.is_open())
Закрытие файла
После завершения работы с файлом его следует закрыть с помощью функции close() . Также стоит отметить, то при выходе объекта потока из области видимости, он удаляется, и у него автоматически вызывается функция close.
#include #include int main() < std::ofstream out; // поток для записи out.open("hello.txt"); // окрываем файл для записи out.close(); // закрываем файл std::ifstream in; // поток для чтения in.open("hello.txt"); // окрываем файл для чтения in.close(); // закрываем файл std::fstream fs; // поток для чтения-записи fs.open("hello.txt"); // окрываем файл для чтения-записи fs.close(); // закрываем файл >