Как написать программу которая будет открывать файлы

Модификации режима в fopen() и freopen() могут быть одним из следующих значений:

• «r» : открыть файл в режиме только для чтения, при этом курсор установлен в начало файла.
• «r+» : открыть файл в режиме чтения-записи, при этом курсор установлен в начало файла.
• «w» : открыть или создать файл в режиме только для записи, при этом его содержимое обрезается до 0 байтов. Курсор установлен в начало файла.
• «w+» : открыть или создать файл в режиме чтения-записи, при этом его содержимое обрезается до 0 байтов. Курсор установлен в начало файла.
• «a» : открыть или создать файл в режиме только записи, при этом курсор установлен в конец файла.
• «a+» : открыть или создать файл в режиме чтения-записи, при этом указатель чтения установлен в начало файла. Выход, однако, всегда будет добавлен в конец файла.

Каждый из этих файловых режимов может иметь b добавленный после начальной буквы (например, «rb» или «a+b» или «ab+» ). b означает, что файл следует рассматривать как двоичный файл вместо текстового файла в тех системах, где есть разница. Это не влияет на Unix-подобные системы; это важно для систем Windows. (Кроме того, Windows fopen позволяет явному t вместо b указывать «текстовый файл» и множество других параметров для конкретной платформы.)

• «wx» : создать текстовый файл в режиме только для записи. Файл может не существовать .
• «wbx» : создать двоичный файл в режиме только для записи. Файл может не существовать .

x , если присутствует, должен быть последним символом в строке режима.

Открыть и записать в файл

#include /* for perror(), fopen(), fputs() and fclose() */ #include /* for the EXIT_* macros */ int main(int argc, char **argv) < int e = EXIT_SUCCESS; /* Get path from argument to main else default to output.txt */ char *path = (argc >1) ? argv[1] : «output.txt»; /* Open file for writing and obtain file pointer */ FILE *file = fopen(path, «w»); /* Print error message and exit if fopen() failed */ if (!file) < perror(path); return EXIT_FAILURE; >/* Writes text to file. Unlike puts(), fputs() does not add a new-line. */ if (fputs(«Output in file.n», file) == EOF) < perror(path); e = EXIT_FAILURE; >/* Close file */ if (fclose(file)) < perror(path); return EXIT_FAILURE; >return e; >

Эта программа открывает файл с именем, указанным в аргументе main, по output.txt для output.txt если аргумент не указан. Если файл с тем же именем уже существует, его содержимое отбрасывается, и файл рассматривается как новый пустой файл. Если файлы еще не существуют, создается вызов fopen() .

Если по какой-либо причине вызов fopen() завершился с ошибкой, он возвращает значение NULL и устанавливает значение глобальной переменной errno . Это означает, что программа может проверить возвращаемое значение после вызова fopen() и использовать perror() если fopen() терпит неудачу.

Если вызов fopen() завершается успешно, он возвращает действительный указатель FILE . Этот указатель затем может использоваться для ссылки на этот файл до тех пор, пока на нем не будет fclose() .

Функция fputs() записывает данный текст в открытый файл, заменяя любое предыдущее содержимое файла. Аналогично функции fopen() функция fputs() также устанавливает значение errno если она терпит неудачу, хотя в этом случае функция возвращает EOF для указания отказа (иначе он возвращает неотрицательное значение).

Функция fclose() сбрасывает любые буферы, закрывает файл и освобождает память, на которую указывает FILE * . Возвращаемое значение указывает на завершение так же, как и fputs() (хотя при успешном завершении возвращает «0»), снова также устанавливая значение errno в случае сбоя.

fprintf

Вы можете использовать fprintf в файле так же, как на консоли с printf . Например, чтобы отслеживать выигрыши игр, потери и связи, которые вы могли бы написать

/* saves wins, losses and, ties */ void savewlt(FILE *fout, int wins, int losses, int ties)

Замечание: некоторые системы (печально, Windows) не используют то, что большинство программистов назвали бы «нормальными» окончаниями строк. Хотя UNIX-подобные системы используют n для завершения строк, Windows использует пару символов: r (возврат каретки) и n (строка). Эта последовательность обычно называется CRLF.

Однако при использовании C вам не нужно беспокоиться об этих деталях, зависящих от платформы. AC-компилятор необходим для преобразования каждого экземпляра n в правильную конечную строку платформы. Поэтому компилятор Windows будет конвертировать n в r n, но компилятор UNIX сохранит его как есть.

Выполнить процесс

#include void print_all(FILE *stream) < int c; while ((c = getc(stream)) != EOF) putchar(c); >int main(void) < FILE *stream; /* call netstat command. netstat is available for Windows and Linux */ if ((stream = popen(«netstat», «r»)) == NULL) return 1; print_all(stream); pclose(stream); return 0; >

Эта программа запускает процесс ( netstat ) через popen() и считывает весь стандартный вывод процесса и выводит его на стандартный вывод.

Примечание: popen() не существует в стандартной библиотеке C , но это скорее часть POSIX C )

Получить строки из файла с помощью getline ()

Библиотека POSIX C определяет функцию getline() . Эта функция выделяет буфер для хранения содержимого строки и возвращает новую строку, количество символов в строке и размер буфера.

Пример программы, которая получает каждую строку из example.txt :

#include #include #define FILENAME «example.txt» int main(void) < /* Open the file for reading */ char *line_buf = NULL; size_t line_buf_size = 0; int line_count = 0; ssize_t line_size; FILE *fp = fopen(FILENAME, «r»); if (!fp) < fprintf(stderr, «Error opening file ‘%s’n», FILENAME); return EXIT_FAILURE; >/* Get the first line of the file. */ line_size = getline(line_buf_size, fp); /* Loop through until we are done with the file. */ while (line_size >= 0) < /* Increment our line count */ line_count++; /* Show the line details */ printf(«line[%06d]: chars=%06zd, buf size=%06zu, contents: %s», line_count, line_size, line_buf_size, line_buf); /* Get the next line */ line_size = getline(line_buf_size, fp); >/* Free the allocated line buffer */ free(line_buf); line_buf = NULL; /* Close the file now that we are done with it */ fclose(fp); return EXIT_SUCCESS; >

Входной файл example.txt

This is a file which has multiple lines with various indentation, blank lines a really long line to show that getline() will reallocate the line buffer if the length of a line is too long to fit in the buffer it has been given, and punctuation at the end of the lines.

Выход

line[000001]: chars=000015, buf size=000016, contents: This is a file line[000002]: chars=000012, buf size=000016, contents: which has line[000003]: chars=000015, buf size=000016, contents: multiple lines line[000004]: chars=000030, buf size=000032, contents: with various indentation, line[000005]: chars=000012, buf size=000032, contents: blank lines line[000006]: chars=000001, buf size=000032, contents: line[000007]: chars=000001, buf size=000032, contents: line[000008]: chars=000001, buf size=000032, contents: line[000009]: chars=000150, buf size=000160, contents: a really long line to show that getline() will reallocate the line buffer if the length of a line is too long to fit in the buffer it has been given, line[000010]: chars=000042, buf size=000160, contents: and punctuation at the end of the lines. line[000011]: chars=000001, buf size=000160, contents:

В этом примере getline() изначально вызывается без выделенного буфера. Во время этого первого вызова getline() выделяет буфер, считывает первую строку и помещает содержимое строки в новый буфер. При последующих вызовах getline() обновляет один и тот же буфер и перераспределяет буфер только тогда, когда он больше не достаточно большой, чтобы соответствовать всей строке. Затем временный буфер освобождается, когда мы закончили с файлом.

Другой вариант — getdelim() . Это то же самое, что и getline() за исключением указания символа окончания строки. Это необходимо, только если последний символ строки для вашего типа файла не является n. getline() работает даже с текстовыми файлами Windows, потому что с завершением многобайтовой строки ( «rn») ‘ n’` по-прежнему остается последним символом в строке.

Пример реализации getline()

#include #include #include #include #if !(defined _POSIX_C_SOURCE) typedef long int ssize_t; #endif /* Only include our version of getline() if the POSIX version isn’t available. */ #if !(defined _POSIX_C_SOURCE) || _POSIX_C_SOURCE < 200809L #if !(defined SSIZE_MAX) #define SSIZE_MAX (SIZE_MAX >> 1) #endif ssize_t getline(char **pline_buf, size_t *pn, FILE *fin) < const size_t INITALLOC = 16; const size_t ALLOCSTEP = 16; size_t num_read = 0; /* First check that none of our input pointers are NULL. */ if ((NULL == pline_buf) || (NULL == pn) || (NULL == fin)) < errno = EINVAL; return -1; >/* If output buffer is NULL, then allocate a buffer. */ if (NULL == *pline_buf) < *pline_buf = malloc(INITALLOC); if (NULL == *pline_buf) < /* Can’t allocate memory. */ return -1; >else < /* Note how big the buffer is at this time. */ *pn = INITALLOC; >> /* Step through the file, pulling characters until either a newline or EOF. */ < int c; while (EOF != (c = getc(fin))) < /* Note we read a character. */ num_read++; /* Reallocate the buffer if we need more room */ if (num_read >= *pn) < size_t n_realloc = *pn + ALLOCSTEP; char * tmp = realloc(*pline_buf, n_realloc + 1); /* +1 for the trailing NUL. */ if (NULL != tmp) < /* Use the new buffer and note the new buffer size. */ *pline_buf = tmp; *pn = n_realloc; >else < /* Exit with error and let the caller free the buffer. */ return -1; >/* Test for overflow. */ if (SSIZE_MAX < *pn) < errno = ERANGE; return -1; >> /* Add the character to the buffer. */ (*pline_buf)[num_read — 1] = (char) c; /* Break from the loop if we hit the ending character. */ if (c == ‘n’) < break; >> /* Note if we hit EOF. */ if (EOF == c) < errno = 0; return -1; >> /* Terminate the string by suffixing NUL. */ (*pline_buf)[num_read] = ‘’; return (ssize_t) num_read; > #endif

Открыть и записать в двоичный файл

#include #include int main(void) < result = EXIT_SUCCESS; char file_name[] = «outbut.bin»; char str[] = «This is a binary file example»; FILE * fp = fopen(file_name, «wb»); if (fp == NULL) /* If an error occurs during the file creation */ < result = EXIT_FAILURE; fprintf(stderr, «fopen() failed for ‘%s’n», file_name); >else < size_t element_size = sizeof *str; size_t elements_to_write = sizeof str; /* Writes str (_including_ the NUL-terminator) to the binary file. */ size_t elements_written = fwrite(str, element_size, elements_to_write, fp); if (elements_written != elements_to_write) < result = EXIT_FAILURE; /* This works for >=c99 only, else the z length modifier is unknown. */ fprintf(stderr, «fwrite() failed: wrote only %zu out of %zu elements.n», elements_written, elements_to_write); /* Use this for fclose(fp); > return result; >

Эта программа создает и записывает текст в двоичной форме через функцию fwrite в файл output.bin .

Если файл с тем же именем уже существует, его содержимое отбрасывается, и файл рассматривается как новый пустой файл.

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

Чтобы записывать целые числа переносимым образом, необходимо знать, ожидает ли формат файла их в формате большой или малой длины, а также размер (обычно 16, 32 или 64 бита). Бит-сдвиг и маскирование могут затем использоваться для записи байтов в правильном порядке. Целые числа в C не гарантируют наличие двух дополняющих представлений (хотя почти все реализации выполняются). К счастью, преобразование в беззнаковый гарантированно использовать двойки комплемента. Поэтому код для записи знакового целого в двоичный файл немного удивителен.

/* write a 16-bit little endian integer */ int fput16le(int x, FILE *fp) < unsigned int rep = x; int e1, e2; e1 = fputc(rep e2 = fputc((rep >> 8) if(e1 == EOF || e2 == EOF) return EOF; return 0; >

Другие функции следуют одному и тому же шаблону с незначительными изменениями для размера и порядка байтов.

fscanf ()

Предположим, у нас есть текстовый файл, и мы хотим прочитать все слова в этом файле, чтобы выполнить некоторые требования.

file.txt :

This is just a test file to be used by fscanf()

Это основная функция:

#include #include void printAllWords(FILE *); int main(void) < FILE *fp; if ((fp = fopen(«file.txt», «r»)) == NULL) < perror(«Error opening file»); exit(EXIT_FAILURE); >printAllWords(fp); fclose(fp); return EXIT_SUCCESS; > void printAllWords(FILE * fp) < char tmp[20]; int i = 1; while (fscanf(fp, «%19s», tmp) != EOF) < printf(«Word %d: %sn», i, tmp); i++; >>
Word 1: This Word 2: is Word 3: just Word 4: a Word 5: test Word 6: file Word 7: to Word 8: be Word 9: used Word 10: by Word 11: fscanf()

Чтение строк из файла

#include #include #include #define MAX_LINE_LENGTH 80 int main(int argc, char **argv) < char *path; char line[MAX_LINE_LENGTH] = ; unsigned int line_count = 0; if (argc < 1) return EXIT_FAILURE; path = argv[1]; /* Open file */ FILE *file = fopen(path, «r»); if (!file) < perror(path); return EXIT_FAILURE; >/* Get each line until there are none left */ while (fgets(line, MAX_LINE_LENGTH, file)) < /* Print each line */ printf(«line[%06d]: %s», ++line_count, line); /* Add a trailing newline to lines that don’t already have one */ if (line[strlen(line) — 1] != ‘n’) printf(«n»); >/* Close file */ if (fclose(file)) < return EXIT_FAILURE; perror(path); >>

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

This is a file which has multiple lines with various indentation, blank lines a really long line to show that the line will be counted as two lines if the length of a line is too long to fit in the buffer it has been given, and punctuation at the end of the lines.

Результатом будет следующий вывод:

line[000001]: This is a file line[000002]: which has line[000003]: multiple lines line[000004]: with various indentation, line[000005]: blank lines line[000006]: line[000007]: line[000008]: line[000009]: a really long line to show that the line will be counted as two lines if the le line[000010]: ngth of a line is too long to fit in the buffer it has been given, line[000011]: and punctuation at the end of the lines. line[000012]:

Этот очень простой пример позволяет фиксированную максимальную длину строки, так что более длинные строки будут эффективно считаться двумя строками. Функция fgets() требует, чтобы вызывающий код предоставлял память, которая будет использоваться в качестве адресата для прочитанной строки.

POSIX делает доступной функцию getline() которая вместо этого внутренне выделяет память, чтобы увеличить буфер, если необходимо, для линии любой длины (при условии, что имеется достаточная память).

Modified text is an extract of the original Stack Overflow Documentation
Лицензировано согласно CC BY-SA 3.0
Не связан с Stack Overflow

• Начало работы с языком C
• — классификация символов и конверсия
• Interprocess Communication (IPC)
• Typedef
• Valgrind
• X-макросы
• Аргументы командной строки
• атомная энергетика
• Битовые поля
• Встраивание
• Встроенная сборка
• Выборочные заявления
• Генерация случайных чисел
• Декларация против определения
• инициализация
• Итерационные выражения / Циклы: для, пока, делать-пока
• Классы хранения
• Комментарии
• компиляция
• Литералы для чисел, символов и строк
• логический
• Массивы
• Многопоточность
• Многосимвольная последовательность символов
• Неопределенное поведение
• Неявные и явные конверсии
• Область идентификатора
• Обработка ошибок
• Обработка сигналов
• Общие идиомы программирования C и методы разработчика
• Общий выбор
• Объявления
• Обычные подводные камни
• Ограничения
• операторы
• Параметры функции
• Передача 2D-массивов в функции
• Перейти к началу страницы
• Переменные аргументы
• Перечисления
• Побочные эффекты
• Поведение, определяемое реализацией
• Препроцессор и макросы
• Прокладка и упаковка структуры
• Псевдонимы и эффективный тип
• Связанные списки
• Создание и включение файлов заголовков
• Составные литералы
• Союзы
• Стандартная математика
• Структуры
• Структуры тестирования
• Струны
• Темы (родной)
• Тип Квалификаторы
• Типы данных
• Точки последовательности
• указатели
• Указатели функций
• Управление памятью
• Утверждение
• Файлы и потоки ввода-вывода
• Форматированный вход / выход

Источник: learntutorials.net

Файлы и исключения в Python

Разрабатывая приложения вам придется работать с файлами, анализировать большие объемы данных, сохранять пользовательские данные, чтобы они не терялись по завершению работы программы. Также при работе с файлами важно научиться обрабатывать ошибки, чтобы они не привели к аварийному завершению программы. Для этого в Python существуют специальные объекты — исключения, которые создаются для управления ошибок.

Содержание страницы:

1. Чтение файла

1.2. Чтение больших файлов и работа с ними

1.3. Анализ текста из файла

2. Запись в файл

2.1. Запись в пустой файл

2.2. Многострочная запись в файл

2.3. Присоединение данных к файлу

3. Исключения

3.1. Блоки try-except

3.2. Блоки try-except- else

3.3. Блоки try-except с текстовыми файлами

3.4. Ошибки без уведомления пользователя

1. Чтение файла в Python

В файлах может содержаться любой объем данных, начиная от небольшого рассказа и до сохранения истории погоды за столетия. Чтение файлов особенно актуально для приложений, предназначенных для анализа данных. Приведем пример простой программы, которая открывает файл и выводит его содержимое на экран. В примере я буду использовать файл с числом «Пи» с точностью до 10 знаков после запятой. Скачать этот файл можно прямо здесь ( pi_10.txt ) или самим создать текстовый файл и сохранить под любым именем. Пример программы, которая открывает файл и выводит содержимое на экран:

with open (‘pi_10.txt’) as file_pi :
digits = file_pi . read()
print(digits)

Код начинается с ключевого слова with . При использование ключевого слова with используемый файл открывается с помощью функции open() , а закрывается автоматически после завершения блока with и вам не придется в конце вызывать функцию close() . Файлы можно открывать и закрывать явными вызовами open() и close() . Функция open() получает один аргумент — имя открываемого файла, в нашем случае ‘pi_10.txt’. Python ищет указанный файл в каталоге, где хранится файл текущей программы. Функция open() возвращает объект, представляющий файл ‘pi_10.txt’. Python сохраняет этот объект в переменной file_pi .

После появления объекта, представляющего файл ‘pi_10.txt’, используется метод read() , который читает все содержимое файла и сохраняет его в одной строке в переменной contents. В конце с помощью функции print содержимое выводится на экран. Запустив этот файл, мы получим данные, находящиеся в нашем файле ‘pi_10.txt’.

3.1415926535

В случае, если файл расположен не в одном каталоге с файлом программы, необходимо указать путь, чтобы Python искал файлы в конкретном месте. Существует два пути как прописать расположение файла:

Относительный путь.

Относительный путь приказывает Python искать файлы в каталоге, который задается относительно каталога, в котором находится текущий файл программы

with open (‘files/имя_файла.txt’) as file :

Абсолютный путь.

Местонахождение файла не зависит от того, где находится ваша программа. Абсолютные пути обычно длиннее относительных, поэтому их лучше сохранить в переменную и затем передать функции open() .

file_path = ‘/Users/Desktop/files/имя_файла.txt’
with open (file_path) as file :

С абсолютными путями можно читать файлы из любого каталога вашей системы.

1.2. Чтение больших файлов на Python и работа с ними

В первом примере был файл с 10 знаками после запятой. Теперь давайте проанализируем файл с миллионом знаков числа «Пи» после запятой. Скачать число «Пи» с миллионом знаков после запятой можно отсюда( ‘pi_1000000.txt’ ). Изменять код из первого примера не придется, просто заменим файл, который должен читать Python.

with open (‘ pi_1000000.txt ‘) as file_pi :
digits = file_pi . read()
print(digits[:102])
print(len(digits))

Выведем на экран первые 100 знаков после запятой. Добавим в конец функцию len, чтобы узнать длину файла

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679

1000002

Из выходных данных видно, что строка содержит значение «Пи» с точностью до 1 000 000 знаков после запятой. В Python нет никаких ограничений на длину данных, с которыми можно работать, единственное ограничение это объем памяти вашей системы.

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

with open (‘ pi_1000000.txt ‘) as file_pi :
digits = file_pi . read()
birthday = input(«Введите дату дня рождения: «)
if birthday in digits:
print(«Ваш день рождение входит в число ‘Пи'»)
else:
print(«Ваш день рождение не входит в число ‘Пи'»)

Начало программы не изменилось, читаем файл и сохраняем данные в переменной digits. Далее запрашиваем данные от пользователя с помощью функции input и сохраняем в переменную birstday. Затем проверяем вхождение birstday в digits с помощью команды if-else. Запустив несколько раз программу, получим результат:

Введите дату дня рождения: 260786
Ваш день рождение не входит в число ‘Пи’

Введите дату дня рождения: 260884
Ваш день рождение входит в число ‘Пи’

В зависимости от введенных данных мы получили результат вхождения или не вхождения дня рождения в число «Пи»

Важно: Читая данные из текстового файла, Python интерпретирует весь текст как строку. Если вы хотите работать с ним в числовом контексте, то преобразуйте данные в целое число функцией int() или в вещественное число функцией float().

1.3. Анализ текста из файла на Python

Python может анализировать текстовые файлы, содержащие целые книги. Возьмем книгу «Алиса в стране чудес» и попробуем подсчитать количество слов в книге. Текстовый файл с книгой можете скачать здесь(‘ alice ‘) или загрузить любое другое произведение. Напишем простую программу, которая подсчитает количество слов в книге и сколько раз повторяется имя Алиса в книге.

with open (filename, encoding=’utf-8′) as file :
contents = file. read()
n_alice = contents. lower() . count( ‘алиса’ )
words = contents. split()
n_words = len (words)

print(f»Книга ‘Алиса в стране чудес’ содержит слов.»)
print(f»Имя Алиса повторяется < n_alice >раз.»)

При открытии файла добавился аргумент encoding=’utf-8′. Он необходим, когда кодировка вашей системы не совпадает с кодировкой читаемого файла. После чтения файла, сохраним его в переменной contents.

Для подсчета вхождения слова или выражений в строке можно воспользоваться методом count() , но прежде привести все слова к нижнему регистру функцией lower() . Количество вхождений сохраним в переменной n_alice.

Чтобы подсчитать количество слов в тексе, воспользуемся методом split() , предназначенный для построения списка слов на основе строки. Метод split() разделяет строку на части, где обнаружит пробел и сохраняет все части строки в элементах списка. Пример метода split() :

title = ‘Алиса в стране чудес’
print(title. split() )

[‘Алиса’, ‘в’, ‘стране’, ‘чудес’]

После использования метода split() , сохраним список в переменной words и далее подсчитаем количество слов в списке, с помощью функции len() . После подсчета всех данных, выведем на экран результат:

Книга ‘Алиса в стране чудес’ содержит 28389 слов.
Имя Алиса повторяется 419 раз.

2.1. Запись в пустой файл в Python

Самый простой способ сохранения данных, это записать их в файл. Чтобы записать текс в файл, требуется вызвать open() со вторым аргументом, который сообщит Python что требуется записать файл. Пример программы записи простого сообщения в файл на Python:

with open (filename, ‘w’ ) as file :
file . write («Язык программирования Python»)

Для начала определим название и тип будущего файла и сохраним в переменную filename. Затем при вызове функции open() передадим два аргумента. Первый аргумент содержит имя открываемого файла. Второй аргумент ‘ w ‘ сообщает Python, что файл должен быть открыт в режиме записи. Во второй строчке метод write() используется для записи строки в файл. Открыв файл ‘ memory.txt ‘ вы увидите в нем строку:

Язык программирования Python

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

Важно: Открывая файл в режиме записи ‘ w ‘, если файл уже существует, то Python уничтожит его данные перед возвращением объекта файла.

Файлы можно открывать в режимах:

• чтение ‘ r ‘
• запись ‘ w ‘
• присоединение ‘ a ‘
• режим как чтения, так и записи ‘ r+ ‘

2.2. Многострочная запись в файл на Python

При использовании функции write() символы новой строки не добавляются в записываемый файл:

with open (filename, ‘w’ ) as file :
file . write («Язык программирования Python»)
file . write («Язык программирования Java»)
file . write («Язык программирования Perl»)

В результате открыв файл мы увидим что все строки склеились:

Язык программирования PythonЯзык программирования JavaЯзык программирования Perl

Для написания каждого сообщения с новой строки используйте символ новой строки n

with open (filename, ‘w’ ) as file :
file . write («Язык программирования Python n «)
file . write («Язык программирования Java n «)
file . write («Язык программирования Perl n «)

Результат будет выглядеть так:

Язык программирования Python
Язык программирования Java
Язык программирования Perl

2.3. Присоединение данных к файлу на Python

Для добавления новых данных в файл, вместо того чтобы постоянно перезаписывать файл, откройте файл в режиме присоединения ‘ a ‘ . Все новые строки добавятся в конец файла. Возьмем созданный файл из раздела 2.2 ‘memory.txt’. Добавим в него еще пару строк.

with open (filename, ‘a’ ) as file :
file . write («Hello worldn»)
file . write («Полет на лунуn»)

В результате к нашему файлу добавятся две строки:

Язык программирования Python
Язык программирования Java
Язык программирования Perl
Hello world
Полет на луну

3. Исключения в Python

При выполнении программ могут возникать ошибки, для управления ими Python использует специальные объекты, называемые исключениями. Когда в программу включен код обработки исключения, ваша программа продолжится, а если нет, то программа остановится и выведет трассировку с отчетом об исключении. Исключения обрабатываются в блоках try-except . С блоками try-except программы будут работать даже в том случае, если что-то пошло не так.

3.1. Блоки try-except на Python

Приведем пример простой ошибки деления на ноль:

Traceback (most recent call last):
File «example.py», line 1, in
print(7/0)
ZeroDivisionError: division by zero

Если в вашей программе возможно появление ошибки, то вы можете заранее написать блок try-except для обработки данного исключения. Приведем пример обработки ошибки ZeroDivisionError с помощью блока try-except :

try :
print(7/0)
except ZeroDivisionError:
print(«Деление на ноль запрещено»)

Команда print(7/0) помещена в блок try . Если код в блоке try выполняется успешно, то Python пропускает блок except . Если же код в блоке try создал ошибку, то Python ищет блок except и запускает код в этом блоке. В нашем случае в блоке except выводится сообщение «Деление на ноль запрещено». При выполнение этого кода пользователь увидит понятное сообщение:

Деление на ноль запрещено

Если за кодом try-except следует другой код, то Python продолжит выполнение программы.

3.2. Блок try-except-else на Python

Напишем простой калькулятор, который запрашивает данные у пользователя, а затем результат деления выводит на экран. Сразу заключим возможную ошибку деления на ноль ZeroDivisionError и добавим блок else при успешном выполнение блока try .

while True:
first_number = input(«Введите первое число: «)
if first_number == ‘q’:
break
second_number = input(«Введите второе число: «)
if second_number == ‘q’:
break
try :
a = int(first_number) / int(second_number)
except ZeroDivisionError:
print(«Деление на ноль запрещено»)
else :
print(f»Частное двух чисел равно «)

Программа запрашивает у пользователя первое число (first_number), затем второе (second_number). Если пользователь не ввел » q » для завершения работы программа продолжается. В блок try помещаем код, в котором возможно появление ошибки. В случае отсутствия ошибки деления, выполняется код else и Python выводит результат на экран. В случае ошибки ZeroDivisionError выполняется блок except и выводится сообщение о запрете деления на ноль, а программа продолжит свое выполнение. Запустив код получим такие результаты:

Введите первое число: 30
Введите второе число: 5
Частное двух чисел равно 6.0
Введите первое число: 7
Введите второе число: 0
Деление на ноль запрещено
Введите первое число: q

В результате действие программы при появлении ошибки не прервалось.

3.3. Блок try-except с текстовыми файлами на Python

Одна из стандартных проблем при работе с файлами, это отсутствие необходимого файла, или файл находится в другом месте и Python не может его найти. Попробуем прочитать не существующий файл:

with open (filename, encoding=’utf-8′) as file :
contents = file. read()

Так как такого файла не существует, Python выдает исключение:

Traceback (most recent call last):
File «example.py», line 3, in
with open(filename, encoding=’utf-8′) as file:
FileNotFoundError: [Errno 2] No such file or directory: ‘alice_2.txt’

FileNotFoundError — это ошибка отсутствия запрашиваемого файла. С помощью блока try-except обработаем ее:

try :
with open (filename, encoding=’utf-8′) as file :
contents = file. read()
except FileNotFoundError:
print(f»Запрашиваемый файл не найден»)

В результате при отсутствии файла мы получим:

Запрашиваемый файл alice_2.txt не найден

3.4. Ошибки без уведомления пользователя

В предыдущих примерах мы сообщали пользователю об ошибках. В Python есть возможность обработать ошибку и не сообщать пользователю о ней и продолжить выполнение программы дальше. Для этого блок try пишется, как и обычно, а в блоке except вы прописываете Python не предпринимать никаких действий с помощью команды pass . Приведем пример ошибки без уведомления:

try :
with open (filename, encoding=’utf-8′) as file :
contents = file. read()
except FileNotFoundError:
pass

В результате при запуске этой программы и отсутствия запрашиваемого файла ничего не произойдет.

Источник: pythonclass.ru

# Файлы — file

Python предоставляет встроенные функции для создания, записи и чтения файлов. Существует два типа файлов, которые могут быть обработаны в Python, обычные текстовые файлы и двоичные (бинарные) файлы (записанные на двоичном языке, 0 и 1).

• text files (от англ. текстовые файлы): в этом типе файлов каждая строка текста заканчивается специальным символом EOL (конец строки), которая по умолчанию является символом новой строки ‘n’ в python.
• binary files (от англ. двоичные файлы): в этом типе файла нет разделителя для строки, и данные сохраняются после преобразования его в понятный машинный двоичный язык.

Сосредоточимся на открытии, закрытии, чтении и записи данных в текстовом файле.

# Режимы доступа к файлам

Access Mode — Режимы доступа определяют тип возможных операций в открытом файле. Это относится к тому, как файл будет использоваться после его открытия. Эти режимы также определяют местоположение дескриптора файла в файле. Дескриптор файла похож на курсор, который определяет, откуда данные должны быть прочитаны или записаны в файл. В питоне есть 6 режимов доступа:

• Read Only ‘r’ (от англ. только чтение): открывает текстовый файл для чтения. Дескриптор располагается в начале файла. Если файл не существует, возникает ошибка ввода-вывода. Это также режим по умолчанию, в котором файл открывается.
• Read and Write ‘r+’ (от англ. чтение и запись): открывает файл для чтения и записи. Дескриптор располагается в начале файла. Вызывает ошибку ввода-вывода, если файл не существует.
• Write Only ‘w’ (от англ. только запись): открывает файл для записи. Для существующего файла данные усекаются и перезаписываются. Дескриптор располагается в начале файла. Создает файл, если файл не существует.
• Write and Read ‘w+’ (от англ. запись и чтение): открывает файл для чтения и записи. Для существующего файла данные усекаются и перезаписываются. Дескриптор располагается в начале файла.
• Append Only ‘a’ (от англ. только добавить): открывает файл для записи. Файл создается, если он не существует. Дескриптор располагается в конце файла. Записываемые данные будут вставлены в конце, после существующих данных.
• Append and Read ‘a+’ (от англ. добавить и прочитать): открывает файл для чтения и записи. Файл создается, если он не существует. Дескриптор располагается в конце файла. Записываемые данные будут вставлены в конце, после существующих данных.

# Открытие файла — open file

Открытие файла делается с помощью встроенной функции open() . Для этой функции не требуется импортировать модуль.

функции open() передают один или два аргумента. Первый – имя файла или имя с адресом, если файл находится не в том каталоге, где находится скрипт. Второй аргумент – режим, в котором открывается файл.

file_object = open(r»File_Name», «Access_Mode»)

Файл должен существовать в том же каталоге, что и программный файл python, в противном случае полный адрес файла должен быть записан на месте имени файла.

r ставится перед именем файла, чтобы символы в строке имени файла не обрабатывались как специальные символы. Например, если в адресе файла есть temp , то t обрабатывается как символ табуляции и возникает ошибка неверного адреса. R делает строку необработанной, то есть сообщает, что строка не имеет специальных символов. Символ r можно игнорировать, если файл находится в том же каталоге и адрес не размещается.

Если файл отсутствует, то открытие его в режиме w создаст новый файл. Бывают ситуации, когда надо гарантировано создать новый файл, избежав случайной перезаписи данных существующего. В этом случае вместо режима w используется режим x . В нем всегда создается новый файл для записи. Если указано имя существующего файла, то будет выброшено исключение. Потери данных в уже имеющемся файле не произойдет.

Если при вызове open() второй аргумент не указан, то файл открывается в режиме чтения как текстовый файл. Чтобы открыть файл как байтовый, дополнительно к букве режима чтения/записи добавляется символ b . Буква t обозначает текстовый файл. Поскольку это тип файла по умолчанию, то обычно ее не указывают.

Нельзя указывать только имя файла без его типа, то есть open(‘имя_файла’, ‘b’) есть ошибка, даже если файл открывается на чтение. Правильно – open(‘имя_файла.тип_файла’, ‘rb’) . Только текстовые файлы мы можем открыть командой open(‘имя_файла’) , потому что и r и t подразумеваются по-умолчанию.

Функция open() возвращает объект файлового типа. Его надо либо сразу связать с переменной, чтобы не потерять, либо сразу прочитать.

# Чтение — read file

С помощью файлового метода read() можно прочитать файл целиком или только определенное количество байт. Создайте в блокноте файл data.txt с таким содержимым:

# /data.txt one — 1 — I two — 2 — II three — 3 — III four — 4 — IV five — 5 — V
1
2
3
4
5
6

Откроем его и почитаем:

file_read = open(‘data.txt’) print(file_read.read(10)) # ‘one — 1 — ‘ print(file_read.read(2)) # ‘In’ print(file_read.read()) # ‘two — 2 — IInthree — 3 — IIInfour — 4 — IVnfive — 5 — Vn’ print(file_read.read()) # » print(type(file_read.read())) #
1
2
3
4
5
6

Сначала считываются первые десять байтов, которые равны десяти символам. Это не бинарный файл, но мы все равно можем читать по байтам. Последующий вызов read() считывает весь оставшийся текст. После этого объект файлового типа file_read становится пустым.

Заметим, что метод read() возвращает строку, и что конец строки считывается как n .

Для того, чтобы читать файл построчно существует метод readline() :

file_read = open(‘data.txt’) print(file_read.readline()) # ‘one — 1 — In’ print(file_read.readline()) # ‘two — 2 — IIn’ print(file_read.readline()) # ‘three — 3 — IIIn’

Метод .readlines() считывает сразу все строки и создает список:

file_read = open(‘data.txt’) print(file_read.readlines()) # [‘one — 1 — In’, ‘two — 2 — IIn’, ‘three — 3 — IIIn’, ‘four — 4 — IVn’, ‘five — 5 — Vn’]

Объект файлового типа относится к так называемым итерируемым объектам. Из таких объектов происходит последовательное извлечение элементов. Поэтому считывать данные из них можно сразу в цикле без использования методов чтения:

for line in open(‘data.txt’): print(line)
one — 1 — I two — 2 — II three — 3 — III four — 4 — IV five — 5 — V
1
2
3
4
5
6
7
8
9
10

Здесь при выводе наблюдаются лишние пустые строки. Функция print() преобразует n в переход на новую строку. К этому добавляет свой переход на новую строку. Создадим список строк файла без n :

numbers = [] for line in open(‘data.txt’): numbers.append(line.strip()) print(numbers) # [‘one — 1 — I’, ‘two — 2 — II’, ‘three — 3 — III’, ‘four — 4 — IV’, ‘five — 5 — V’]

Переменной line присваивается очередная строка файла. Метод line.strip() очищает стоку от лишних пробелов справа или с лева от стоки и удаляет n .

# Упражнения

1. Создайте файл numbers.txt , содержащий несколько чисел, записанных через пробел:

1 12 4 15 40

Напишите программу, которая подсчитывает и выводит на экран общую сумму чисел, хранящихся в этом файле. Алгоритм должен быть универсальным. Числа могут быть различной длины, разделяться несколькими пробелами и записанными в несколько строк. Проверьте работу написанного алгоритма на новом файле new_numbers.txt:

New initial data: 37 8 4 111 1000 1
Clothes Prices jacket — 4 500 socks — 500 umbrella — 900 belt — 1 000 slippers — 90
1
2
3
4
5
6
7

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

. backpack — 14 999.99 flip-flops — 350,99 fur coat — 26 000
1. The capital of Russia is . — London + Moscow — Berlin — Paris
Проверьте корректность работы генератора интерфейса, на примере измененного файла questions.txt:
1. The capital of the Great Britain is . + London — Moscow — Berlin — Paris — St.-Petersburg 2. What country is European? — Japan — China + Spain
1
2
3
4
5
6
7
8
9
10
11

• варианты ответа после вопроса выводятся в случайном порядке.
• реализуйте проверку выбранных ответов.
• подсчитайте количество правильных и не правильных ответов, выбранных пользователем.
• замените вопросы в файле questions.txt , и проверьте работу программы с новыми вопросами.

1. What sea with the name of the color does not exist? — Blacken — Red + Blue — Yellow — White 2. Which country is the second largest in the world? + Canada -Russia -USA -China 3. What are the tallest mountains in the world? Ural Andes + Himalayas Alps Caucasian
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# Запись в файл — write file

Запись в файл выполняется с помощью методов .write() и .writelines() . Во второй можно передать структуру данных:

list_numbers = [‘tree’, ‘four’] file_write = open(‘new_data.txt’, ‘w’) print(file_write.write(‘onen’)) # 4 print(file_write.write(‘two’)) # 3 print(file_write.writelines(list_numbers)) # None

Метод .write() возвращает количество записанных символов. n — символ переноса строки, считается за один символ.

В результате выполнения кода в появиться файл new_data.txt с текстом в нем

one twotreefour

# Закрытие файла — close file

После того как работа с файлом закончена, важно не забывать его закрыть, чтобы освободить место в памяти. Делается это с помощью файлового метода close() . Свойство файлового объекта closed позволяет проверить закрыт ли файл:

file_read.close() print(file_read.closed) # True print(file_write.closed) # False

Если файл открывается в заголовке цикла for line in open(«file_name») , то видимо интерпретатор его закрывает при завершении работы цикла.

# Oператор with

В Python имеется инструмент, применяя который может упростить чтение и редактирование файлов. Оператор with создает диспетчер контекста, который автоматически закрывает файл для вас, по окончанию работы в нем. Посмотрим, как это работает:

with open(«data.txt») as data_file: print(data_file.read())

Синтаксис для оператора with . as . не сложен. Фактически, все, что мы делаем в данном примере, это:

data_file = open(«test.txt»)
with open(«test.txt») as data_file:

Далее можно выполнять все стандартные операции вводавывода, в привычном порядке, пока находитесь в пределах блока. После того, как вы покинете блок кода, файловый дескриптор закроет его, и его уже нельзя будет использовать. Т.е. более нет необходимости закрывать файл, так как оператор делает это автоматически.

# Упражнения

1. Напишите программу создающую файл week_days.txt со следующим содержимым:

1. Monday 2. Tuesday 3. Wednesday 4. Thursday 5. Friday 6. Saturday 7. Sunday
1
2
3
4
5
6
7
four — 4 — IV two — 2 — II one — 1 — I three — 3 — III five — 5 — V four — 4 — IV one — 1 — I
1
2
3
4
5
6
7

# Упражнения tkinter

1. Напишите программу, которая сохраняет данные из Listbox() в текстовый файл.
2. Напишите программу, загружающую содержимое текстового файла в виджет Listbox() .
3. Напишите программу, которая загружает данные из файла в Listbox() . Позволяет добавить и удалить данные и сохраняет изменения в файл.
4. Напишите программу для составления списка вопросов. Левая сторона программы содержит:
5. поля подписей,
6. многострочное поле ввода вопроса,
7. многострочное поле ввода правильного ответа,
8. многострочное поля ввода неправильных вариантов ответа с вертикально полосой прокрутки,
9. кнопка добавления вопроса в правое многострочное текстовое поле, (предпросмотр).

Правая сторона содержит:

• правое многострочное текстовое поле (предпросмотр) с вертикально полосой прокрутки, с выводам всего документа вопросов.
• кнопка сохранения текста в документ questions_new.txt , с вызовом диалогового окна выбора документа.

• Для многострочных полей реализовать перенос по словам,
• Перед добавлением вопроса из левой формы, реализовать проверку на пустоту всех полей.
• Реализовать множественное добавление вопросов, с увеличением номера следующего вопроса.
• Перед сохранением документа реализовать предупреждение перезаписи документа и вопроса согласия пользователя на перезапись.
• После переноса вопроса из левой стороны в правую, все поля левой стороны очищаются.
• Задайте ограничение минимального размера окна 400х300 .
• При изменении размера окна, интерфейс должен отображаться корректно.

Which country is no more? + Rome + USSR — Finland — Poland

Источник: learn4kid-python.firebaseapp.com