Ввод данных из файла и вывод в файл в языке программирования С
До этого при вводе-выводе данных мы работали со стандартными потоками — клавиатурой и монитором. Теперь рассмотрим, как в Си реализовано получение данных из файлов и запись их туда. Перед тем как выполнять эти операции, надо открыть файл и получить доступ к нему.
В языке программирования C указатель на файл имеет тип FILE и его объявление выглядит так:
FILE *myfile;
С другой стороны, функция fopen() открывает файл по указанному в качестве первого аргумента адресу в режиме чтения «r», записи «w» или добавления «a» и возвращает в программу указатель на него. Поэтому процесс открытия файла и подключения его к программе выглядит примерно так:
myfile = fopen("hello.txt", "r");
Примечание. В случае использования относительной адресации текущим/рабочим каталогом в момент исполнения программы должен быть тот, относительно которого указанный относительный адрес корректен. Место нахождения самого исполняемого файла не важно.
При чтении или записи данных в файл обращение к нему осуществляется посредством файлового указателя (в данном случае, myfile ).
Если в силу тех или иных причин (нет файла по указанному адресу, запрещен доступ к нему) функция fopen() не может открыть файл, то она возвращает NULL . В реальных программах почти всегда обрабатывают ошибку открытия файла в ветке if , мы же далее опустим это.
Объявление функции fopen содержится в заголовочном файле stdio.h , поэтому требуется его подключение. Также в stdio.h объявлен тип-структура FILE .
После того, как работа с файлом закончена, принято его закрывать, чтобы освободить буфер от данных и по другим причинам. Это особенно важно, если после работы с файлом программа продолжает выполняться. Разрыв связи между внешним файлом и указателем на него из программы выполняется с помощью функции fclose() . В качестве аргумента ей передается указатель на файл:
fclose(myfile);
В программе может быть открыт не один файл. В таком случае каждый файл должен быть связан со своим файловым указателем. Однако если программа сначала работает с одним файлом, потом закрывает его, то указатель можно использовать для открытия второго файла.
Чтение из текстового файла и запись в него
fscanf
Функция fscanf() аналогична по смыслу функции scanf() , но в отличии от нее осуществляет форматированный ввод из файла, а не стандартного потока ввода. Функция fscanf() принимает параметры: файловый указатель, строку формата, адреса областей памяти для записи данных:
fscanf(myfile, "%s%d", str, &a);
Возвращает количество удачно считанных данных или EOF. Пробелы, символы перехода на новую строку учитываются как разделители данных.
Допустим, у нас есть файл содержащий такое описание объектов:
apples 10 23.4 bananas 5 25.0 bread 1 10.3
Тогда, чтобы считать эти данные, мы можем написать такую программу:
#include int main () { FILE *file; struct food { char name[20]; unsigned qty; float price; }; struct food shop[10]; char i = 0; file = fopen("goods.txt", "r"); while (fscanf(file, "%s%u%f", shop[i].name, &(shop[i].qty), &(shop[i].price)) != EOF) { printf("%s %u %.2f\n", shop[i].name, shop[i].qty, shop[i].price); i++; } }
В данном случае объявляется структура и массив структур. Каждая строка из файла соответствует одному элементу массива; элемент массива представляет собой структуру, содержащую строковое и два числовых поля. За одну итерацию цикл считывает одну строку. Когда встречается конец файла fscanf() возвращает значение EOF и цикл завершается.
fgets
Функция fgets() осуществляет построчный ввод из файла. Один вызов fgets() позволят прочитать одну строку. При этом можно прочитать не всю строку, а лишь ее часть от начала. Параметры fgets() выглядят таким образом:
fgets(массив_символов, количество_считываемых_символов, указатель_на_файл)
fgets(str, 50, myfile)
Такой вызов функции прочитает из файла, связанного с указателем myfile , одну строку текста полностью, если ее длина меньше 50 символов с учетом символа ‘\n’, который функция также сохранит в массиве. Последним (50-ым) элементом массива str будет символ ‘\0’, добавленный fgets . Если строка окажется длиннее, то функция прочитает 49 символов и в конце запишет ‘\0’. В таком случае ‘\n’ в считанной строке содержаться не будет.
#include #define N 80 int main() { FILE *file; char arr[N]; file = fopen("goods.txt", "r"); while (fgets(arr, N, file) != NULL) printf("%s", arr); printf("\n"); fclose(file); }
В этой программе в отличие от предыдущей данные считываются строка за строкой в массив arr . Когда считывается следующая строка, предыдущая теряется. Функция fgets() возвращает NULL в случае, если не может прочитать следующую строку.
getc или fgetc
Функция getc() или fgetc() (работает и то и другое) позволяет получить из файла очередной один символ.
#include #define N 80 int main() { FILE *file; char str[N]; int i; file = fopen("goods.txt", "r"); while ((str[i] = fgetc(file)) != EOF) { if (str[i] == '\n') { str[i] = '\0'; printf("%s\n", str); i = 0; } else i++; } str[i] = '\0'; printf("%s\n",str); fclose(file); }
Приведенный в качестве примера код выводит данные из файла на экран.
Запись в текстовый файл
Также как и ввод, вывод в файл может быть различным.
- Форматированный вывод. Функция fprintf( файловый_указатель, строка_формата, переменные ) .
- Построчный вывод. Функция fputs( строка, файловый_указатель ) .
- Посимвольный вывод. Функция fputc() или putc( символ, файловый_указатель ) .
Ниже приводятся примеры кода, в которых используются три способа вывода данных в файл.
Запись в каждую строку файла полей одной структуры (прерывание в Linux ‒ Ctrl + D ):
#include #define N 80 int main() { FILE *file; char str[N]; int i; file = fopen("goods.txt", "r"); while ((str[i] = fgetc(file)) != EOF) { if (str[i] == '\n') { str[i] = '\0'; printf("%s\n", str); i = 0; } else i++; } str[i] = '\0'; printf("%s\n",str); fclose(file); }
Построчный вывод в файл ( fputs() , в отличие от puts() сама не помещает в конце строки ‘\n’):
#include int main () { FILE *file; char str[10]; file = fopen("output.txt", "w"); while (scanf("%s", str) != EOF) { fputs(str, file); fputs("\n", file); } fclose(file); }
Пример посимвольного вывода:
#include int main() { FILE *file; char i; file = fopen("output.txt", "w"); while ((i = getchar()) != EOF) fputc(i, file); fclose(file); }
Чтение из двоичного файла и запись в него
С файлом можно работать не как с последовательностью символов, а как с последовательностью байтов. В принципе, с нетекстовыми файлами работать по-другому не возможно. Однако так можно читать и писать и в текстовые файлы. Преимущество такого способа доступа к файлу заключается в скорости чтения-записи: за одно обращение можно считать/записать существенный блок информации.
При открытии файла для двоичного доступа, вторым аргументом fopen() является строка «rb» или «wb».
Тема о работе с двоичными файлами достаточно сложная, для ее изучения требуется отдельный урок. Здесь будут отмечены только особенности функций чтения-записи в файл, который рассматривается как поток байтов.
Функции fread() и fwrite() имеют следующие параметры:
- адрес области памяти, куда данные записываются или откуда считываются,
- размер одного данного какого-либо типа,
- количество считываемых данных указанного размера,
- файловый указатель.
Эти функции возвращают количество успешно прочитанных или записанных данных. Т.е. можно «заказать» считывание 50 элементов данных, а получить только 10. Ошибки при этом не возникнет.
Пример использования функций fread() и fwrite() :
#include #include int main() { FILE *file; char shelf1[50], shelf2[100]; int n, m; file = fopen("shelf1.txt", "rb"); n = fread(shelf1, sizeof(char), 50, file); fclose(file); file = fopen("shelf2.txt", "rb"); m = fread(shelf2, sizeof(char), 50, file); fclose(file); shelf1[n] = '\0'; shelf2[m] = '\n'; shelf2[m+1] = '\0'; file = fopen("shop.txt", "wb"); fwrite(strcat(shelf2, shelf1), sizeof(char), n+m, file); fclose(file); }
Здесь осуществляется попытка чтения из первого файла 50-ти символов. В n сохраняется количество реально считанных символов. Значение n может быть равно 50 или меньше. Данные помещаются в строку. То же самое происходит со вторым файлом. Далее первая строка присоединяется ко второй, и данные сбрасываются в третий файл.
Курс с решением задач:
pdf-версия
При помощи какого оператора текстовый файл открывается для перезаписи
Для работы с файлами в стандартной библиотеке определен заголовочный файл 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(); // закрываем файл >
Ввод-вывод, оператор присваивания, арифметические операции
Теоретический материал: файловый ввод-вывод (Паскаль)
Файлы. Виды файлов. Основные процедуры для работы с файлами
До сих пор мы рассматривали задачи, в которых во время выполнения программы данные поступают с клавиатуры, а результаты выводятся на экран дисплея. При этом ни исходные данные, ни результаты не сохраняются. Всякий раз при выполнении одной и той же программы, в частности, во время отладки, приходится заново вводить данные. А если их очень много? В языке Паскаль есть возможность записать их на диск. Для этого необходимо оформить исходные данные и результаты в виде файлов, которые хранятся на диске точно так же, как и программы.
Понятие файла — это фундаментальное понятие информатики, вспомним же его определение.
Определение. Файлом называется область памяти на диске, имеющая свое имя.
Вы знаете различные виды физических файлов: системные, графические, текстовые и другие, зачастую созданные той или иной прикладной программой. И любой из этих физических файлов Вы сможете считать, проанализировать, изменить и записать.
Физические файлы можно по-разному представить в программе. Язык Турбо Паскаль предлагает три вида представления файлов:
И Вы, в зависимости от решаемой задачи, вольны выбирать один их трех видов, а, может быть, и несколько. Для того, чтобы сделать правильный выбор, Вы должны хорошо знать не только процедуры и функции, являющиеся общими для всех видов файлов, но и специфичные для каждого вида.
Для работы с конкретным физическим файлом на диске надо представить в программе так называемую файловую переменную и произвести ее логическую связку с этим файлом. Файловые переменные имеют специфическое применение. Над ними нельзя выполнять никаких операций (присваивать значение, сравнивать и др.). Их можно использовать только для выполнения операций с файлами (чтения, записи, удаления файла и т.д.). Кроме того, через файловую переменную можно получить информацию о конкретном файле (тип, параметры, имя файла и т.д.).
По сути, любой физический файл можно представить как последовательность блоков информации некоторого типа. Все компоненты файла имеют общее имя, а каждый имеет еще и свой номер. Начальный элемент имеет нулевой номер.
Количество элементов файла может быть любым: число компонентов файла может изменяться (увеличиваться или уменьшаться), то есть, заранее не фиксируется. В файлах можно хранить достаточно большое количество данных. После каждого элемента файла автоматически ставится признак конца элемента, а в конце файла ставится признак конца файла.
С каждым файлом можно связать понятие «текущий указатель». Это неявно описанная переменная, которая указывает на конкретный элемент файла. Действия с файлами производятся поэлементно, причем в них участвует тот элемент, на который «смотрит» текущий указатель, перемещающийся в результате выполнения действия на следующий элемент.
Главное, чему необходимо научиться при работе с файлами — это записать информацию из программы в файл и считать нужную информацию в выделенную переменную для обработки программой. Общая последовательность действий при этом такова:
— описать переменную файлового типа;
— связать ее с конкретным физическим файлом процедурой 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).
Функция open() в Python, открывает файл на чтение/запись
Открывает файл для чтения или записи файлового потока
Синтаксис:
fp = open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
Параметры:
- file — абсолютное или относительное значение пути к файлу или файловый дескриптор открываемого файла.
- mode — необязательно, строка, которая указывает режим, в котором открывается файл. По умолчанию ‘r’ .
- buffering — необязательно, целое число, используемое для установки политики буферизации.
- encoding — необязательно, кодировка, используемая для декодирования или кодирования файла.
- errors — необязательно, строка, которая указывает, как должны обрабатываться ошибки кодирования и декодирования. Не используется в -бинарном режиме
- newline — необязательно, режим перевода строк. Варианты: None , ‘\n’ , ‘\r’ и ‘\r\n’ . Следует использовать только для текстовых файлов.
- closefd — необязательно, bool , флаг закрытия файлового дескриптора.
- opener — необязательно, пользовательский объект, возвращающий открытый дескриптор файла.
Возвращаемое значение:
Описание:
Функция open() открывает файл для чтения или записи при помощи файлового потока. Если файл не может быть открыт, бросается исключение OSError .
Функция возвращает файловый объект, который имеет методы, позволяющие читать и записывать информацию различными способами.
Аргумент file — это строка, определяющая абсолютное или относительное расположение открываемого файла в файловой системе или целочисленный файловый дескриптор файла. Если задан файловый дескриптор, он закрывается, когда возвращаемый файловый поток закрывается, если для closefd не установлено значение False .
Изменено в Python 3.6: В аргумент file добавлена поддержка приема объектов, реализующих os.PathLike . Обратите внимание, что модуль pathlib реализует протокол os.PathLike .
Аргумент mode — это необязательная строка, которая указывает режим, в котором открывается файл. По умолчанию ‘r’ , это означает, что файл открыт для чтения в текстовом режиме. Другими распространенными значениями являются ‘w’ для записи (очищает файл, если он уже существует), ‘x’ для монопольного создания и ‘a’ для добавления (что в некоторых системах Unix означает, что все операции записи добавляются в конец файла) независимо от текущей позиции указателя файла). В текстовом режиме, если кодировка не указана, используемая кодировка зависит от платформы: вызывается locale.getencoding() для получения текущей кодировки локали. (Для чтения и записи необработанных байтов нужно использовать двоичный режим и оставить кодировку неуказанной.) Доступны следующие режимы:
Значения аргумента mode :
- r — открывает файл только для чтения,
- w — открыт для записи (перед записью файл будет очищен),
- x — эксклюзивное создание, бросается исключение FileExistsError , если файл уже существует.
- a — открыт для добавления в конец файла (на некоторых Unix-системах пишет в конец файла вне зависимости от позиции курсора)
- + — символ обновления (чтение + запись).
- t — символ текстового режима.
- b — символ двоичного режима (для операционных систем, которые различают текстовые и двоичные файлы).
Режим по умолчанию ‘r’ , открывает файл только для чтения текста, синоним ‘rt’ . Режимы ‘r+’ и ‘r+b’ открывают файл и устанавливают курсор на начало файла, запись в файл начинается с места остановки курсора при его чтении перед записью. Если файл перед записью не читался то запись осуществляется в начало файла. Режимы ‘w’ и ‘wb’ создают новый файл или открывают существующий файл только для записи, с последующей его очисткой (стирает все перед записью). У режимов ‘w+’ и ‘wb+’ поведение такое же как в предыдущем случае, только если не закрывать файл после записи, его еще можно потом прочитать.
Варианты использования режимов:
- ‘r’ — Открывает файл только для чтения. Указатель файла помещается в начале файла. Это режим «по умолчанию».
- ‘rb’ — Открывает файл в бинарном режиме только для чтения. Указатель файла помещается в начале файла. Это режим «по умолчанию».
- ‘r+’ — Открывает файл для чтения и записи. Указатель файла помещается в начало файла.
- ‘rb+’ — Открывает файл в бинарном режиме для чтения и записи. Указатель файла помещается в начале файла. Это режим «по умолчанию».
- ‘w’ — Открывает файл только для записи. Перезаписывает файл, если файл существует. Если файл не существует, создает новый файл для записи.
- ‘wb’ — Открывает файл в бинарном режиме только для записи. Перезаписывает файл, если файл существует. Если файл не существует, создает новый файл для записи.
- ‘w+’ — Открывает файл для записи и чтения. Перезаписывает существующий файл, если файл существует. Если файл не существует, создается новый файл для чтения и записи.
- ‘wb+’ — Открывает файл в бинарном режиме для записи и чтения. Перезаписывает существующий файл, если файл существует. Если файл не существует, создается новый файл для чтения и записи.
- ‘a’ — Открывает файл для добавления. Указатель файла находится в конце файла, если файл существует. То есть файл находится в режиме добавления. Если файл не существует, он создает новый файл для записи.
- ‘ab’ — Открывает файл в бинарном режиме для добавления. Указатель файла находится в конце файла, если файл существует. То есть файл находится в режиме добавления. Если файл не существует, он создает новый файл для записи.
- ‘a+’ — Открывает файл для добавления и чтения. Указатель файла находится в конце файла, если файл существует. Файл открывается в режиме добавления. Если файл не существует, он создает новый файл для чтения и записи.
- ‘ab+’ — Открывает файл в бинарном режиме для добавления и чтения. Указатель файла находится в конце файла, если файл существует. Файл открывается в режиме добавления. Если файл не существует, он создает новый файл для чтения и записи.
Python различает двоичный и текстовый ввод/вывод. Файлы, открытые в двоичном режиме, возвращают содержимое в виде bytes объектов без какого-либо декодирования. В текстовом режиме (по умолчанию или когда ‘t’ включен в аргумент mode ) содержимое файла возвращается как строка байтов, которые были сначала декодированы с использованием кодировки, используемой системой по умолчанию или с использованием переданного аргумента encoding .
Аргумент buffering — необязательное целое число, используемое для установки политики буферизации.
- 0 — отключить буферизацию, только для бинарного режима;
- 1 — построчная буферизация, только для текстового режима;
- int число > 1 — размер буфера в байтах.
- -1 — по умолчанию.
У текстовых файлов, если buffering не задан, используется построчная буферизаця. Двоичные файлы буферизируются кусками фиксированного размера. Этот размер определяется эвристикой, пытающейся определить размер блока устройства, на котором находится файл, в случае неудачи использует io.DEFAULT_BUFFER_SIZE . Для многих систем буфер равен 4096 или 8192 байт.
Аргумент encoding — это имя кодировки, используемой для декодирования или кодирования файла. Это аргумент следует использовать только в текстовом режиме. Кодировка по умолчанию зависит от платформы, но может использоваться любая кодировка текста, поддерживаемая Python.
Аргумент error является необязательным и указывает как должны обрабатываться ошибки кодирования и декодирования. Следует использовать только для текстовых файлов.
Доступны стандартные обработчики ошибок:
- ‘strict’ — бросает исключение ValueError , если есть ошибка кодирования. Значение по умолчанию None имеет тот же эффект.
- ‘ignore’ — игнорирует ошибки. Обратите внимание, что игнорирование ошибок кодирования может привести к потере данных.
- ‘replace’ — вставляет символ ? на место непрочитанных символов, ввиду их отсутствия в используемой кодировке.
- ‘surrogateescape’ — любые некорректные байты будут представлены как символы Юникода в диапазоне от U+DC80 до U+DCFF . Эти символы, при обратной операции кодирования будут возвращаться в те же байты. Полезно для обработки файлов в неизвестной кодировке.
- ‘xmlcharrefreplace’ — поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей ссылкой на символ XML.
- ‘backslashreplace’ — заменяет искаженные данные на escape-последовательности Python с обратной косой чертой.
- ‘namereplace’ — поддерживается только при записи, заменяет не поддерживаемые символы на \N escape-последовательности.
Аргумент newline контролирует работу режима новой строки. Работает только с текстовым режимом. Допустимые аргументы: None , » , ‘\n’ , ‘\r’ и ‘\r\n’ .
Это работает следующим образом:
- Чтение файла:
- если аргумент newline=None или не указан, то символами окончания строк ‘\n’ , ‘\r’ или ‘\r\n’ на выходе преобразуются в разделитель строки ‘\n’ .
- если newline=» , то получим результат с вырезанными символами окончания строк ‘\n’ , ‘\r’ или ‘\r\n’ , то есть файл прочитается как одна большая строка.
- если newline=’\n’ , то в результате чтения функция open() уберет только символ \n из результата, если newline=’\r’ , то только \r , если newline=’\r\n’ , то только сочетание ‘\r\n’ не будет учитываться.
- если аргумент newline=None или не указан, то символы окончания строк \n будут переведены в разделители строк, которые система использует по умолчанию;
- если newline=» или newline=’\n’ , то символы окончания строк \n переводится в разделители строк не будут. В файл запишется одна большая строка.
- если newline=’\r’ , то в результате записи функция open() сохранит значение \r в качестве разделителя строк, если newline=’\r\n’ , то запишется сочетание ‘\r\n’ .
Аргумент closefd по умолчанию True . Если аргумент closefd=False и вместо имени файла был задан его дескриптор, то при закрытии файла функцией open() , базовый дескриптор файла будет оставаться открытым. Если задано имя файла, closefd должно быть True (по умолчанию), иначе возникнет ошибка.
Необязательный аргумент opener (по умолчанию None ), пользовательский объект поддерживающий вызов, который следует использовать для открытия файла. Этот объект получая на входе file и flags , должен возвращать открытый дескриптор файла.
Дополнительно смотрите функцию os.open() , которая открывает файл и возвращает его файловый дескриптор. Вновь созданный дескриптор не наследуется .
В следующем примере используется параметр dir_fd функции os.open() , чтобы открыть файл относительно данного каталога:
>>> import os >>> dir_fd = os.open('/some/dir', os.O_RDONLY) >>> def opener(path, flags): . return os.open(path, flags, dir_fd=dir_fd) . >>> with open('test.txt', 'w', opener=opener) as f: . print('This will be written to /some/dir/test.txt', file=f) . >>> os.close(dir_fd) # не забывайте закрыть файловый дескриптор
Тип файлового объекта, возвращаемого функцией open() , зависит от режима. Когда используется open() , чтобы открыть файл в текстовом режиме ‘w’ , ‘r’ , ‘wt’ , ‘rt’ и т. д., она возвращает подкласс io.TextIOBase , в частности io.TextIOWrapper . При использовании для открытия файла в двоичном режиме с буферизацией возвращаемый класс является подклассом io.BufferedIOBase .
Итоговый класс меняется в зависимости от операции:
- в режиме чтения двоичных файлов он возвращает io.BufferedReader ;
- в двоичном режиме записи и в двоичном режиме добавления он возвращает io.BufferedWriter ;
- в режиме чтения/записи — io.BufferedRandom .
Когда отключена буферизация, исходный поток возвращает подклассы io.RawIOBase , io.FileIO .
Примеры чтения из файла и записи в файл.
Чтение и вывод на печать сразу всего файла:
f = open('demofile.txt', 'r') print(f.read()) f.close() # не забывайте закрыть файл
Чтение всего файла и вывод на печать построчно:
f = open('demofile.txt', 'r') for line in f: print(line) f.close() # не забывайте закрыть файл
Создадим файл newfile.txt и запишем в него строку. Если файл с таким именем уже существует, то данные внутри файла сотрутся.
f = open('newfile.txt', 'w') f.write('Это единственная строка в файле\n') f.close() # не забывайте закрыть файл
Использование менеджера контекста для чтения/записи в файл.
Открываем файл на запись с помощью менеджера контекста и пишем данные в конец файла.
with open('demofile.txt', 'a') as f: f.write('Привет Мир\n') # здесь закрывать файл не надо, менеджер контекста сделает это сам.
- ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
- Функция abs(), абсолютное значение числа
- Функция all(), все элементы True
- Функция any(), хотя бы один элемент True
- Функция ascii(), преобразует строку в ASCII
- Функция bin(), число в двоичную строку
- Класс bool(), логическое значение объекта
- Функция breakpoint(), отладчик кода
- Класс bytearray(), преобразует в массив байтов
- Класс bytes(), преобразует в строку байтов
- Функция callable(), проверяет можно ли вызвать объект
- Функция chr(), число в символ Юникода
- Класс classmethod, делает функцию методом класса
- Функция compile() компилирует блок кода Python
- Класс complex(), преобразует в комплексное число
- Функция delattr(), удаляет атрибут объекта
- Класс dict() создает словарь
- Функция dir(), все атрибуты объекта
- Функция divmod(), делит числа с остатком
- Функция enumerate(), счетчик элементов последовательности
- Функция eval(), выполняет строку-выражение с кодом
- Функция exec(), выполняет блок кода
- Функция filter(), фильтрует список по условию
- Класс float(), преобразует в вещественное число
- Функция format(), форматирует значение переменной
- Класс frozenset(), преобразует в неизменяемое множество
- Функция getattr(), значение атрибута по имени
- Функция globals(), переменные глобальной области
- Функция hasattr(), наличие атрибута объекта
- Функция hash(), хэш-значение объекта
- Функция help(), справка по любому объекту
- Функция hex(), число в шестнадцатеричную строку
- Функция id(), идентификатор объекта
- Функция input(), ввод данных с клавиатуры
- Класс int(), преобразует в тип int
- Функция isinstance(), принадлежность экземпляра к классу
- Функция issubclass(), проверяет наследование класса
- Функция iter(), создает итератор
- Функция len(), количество элементов объекта
- Класс list(), преобразовывает в список
- Функция locals(), переменные локальной области
- Функция map(), обработка последовательности без цикла
- Функция max(), максимальное значение элемента
- Класс memoryview(), ссылка на буфер обмена
- Функция min(), минимальное значение элемента
- Функция next(), следующий элемент итератора
- Класс object(), возвращает безликий объект
- Функция oct(), число в восьмеричную строку
- Функция open(), открывает файл на чтение/запись
- Функция ord(), число символа Unicode
- Функция pow(), возводит число в степень
- Функция print(), печатает объект
- Класс property(), метод класса как свойство
- Класс range(), генерирует арифметические последовательности
- Функция repr(), описание объекта
- Функция reversed(), разворачивает последовательность
- Функция round(), округляет число
- Класс set(), создает или преобразовывает в множество
- Функция setattr(), создает атрибут объекта
- Класс slice(), шаблон среза
- Функция sorted(), выполняет сортировку
- Декоратор staticmethod(), метод класса в статический метод
- Класс str(), преобразует объект в строку
- Функция sum(), сумма последовательности
- Функция super(), доступ к унаследованным методам
- Класс tuple(), создает или преобразует в кортеж
- Класс type(), возвращает тип объекта
- Функция vars(), словарь переменных объекта
- Функция zip(), объединить элементы в список кортежей
- Функция __import__(), находит и импортирует модуль
- Функция aiter(), создает асинхронный итератор
- Функция anext(), следующий элемент асинхронного итератора