Файл закрыть: Метод file.close() в Python, закрывает файл

Содержание

Закрыть файл | Работа в МойОфис Текст Настольная версия

Создать файлСоздать шаблон файлаСоздать файл из шаблонаОткрыть файлОткрыть недавние документыОткрыть файл в другом приложенииСохранить файлОтправить файл по почтеЭкспортировать файлРаспечатать документ без входа в приложениеРаспечатать документЗакрыть файл

  • Создать файл

  • Создать шаблон файла

  • Создать файл из шаблона

  • Открыть файл

  • Открыть недавние документы

  • Открыть файл в другом приложении

  • Сохранить файл

  • Отправить файл по почте

  • Экспортировать файл

  • Распечатать документ без входа в приложение

  • Распечатать документ

  • Закрыть файл

Продукт: МойОфис Профессиональный, МойОфис Стандартный, МойОфис Образование, МойОфис Текст

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

•Выберите пункт командного меню Файл > Закрыть.

•Нажмите кнопку Закрыть в заголовке окна приложения.

•Нажмите сочетание клавиш Alt+F4.

Поделиться:

Был ли материал полезным?

Пользователи, считающие этот материал полезным: 0 из 0

Предыдущее

Почему важно закрывать файлы в Python? • Школа программирования Pylot.me

Python

Alexander Lukyanov

2022-10-11

Чем чреваты файлы, своевременно не закрытые в операционной системе

При создании программного обеспечения с функциями обработки файлов, у вас всегда есть риск получения ошибки операционной системы (ОС) типа ‘Too many open files’ – слишком много открытых файлов. Это объясняется тем, что количество открытых файлов, как и любой другой ресурс для ОС всегда является ограниченным. Конечно, в теории современные компьютеры способны одновременно обрабатывать сотни тысяч, а то и миллионы открытых файлов. Но реально, следует учитывать, что с нарастанием функциональных возможностей и сервисов ОС, их контроль должен распределяться на все большое количество технических параметров и возможностей компьютера. Следовательно, удельный вес ресурсов, отведенных в ОС на работу с файлами, снижается. Так, на примере нижеприведенного фрагмента Python программы можно увидеть, что даже количество в несколько десятков тысяч одновременно открытых файлов, далеко не всегда приемлемо для современных ОС и компьютеров:

>>> files = [open(f"file-{n}.txt", mode="w") for n in range(10000)]
Traceback (most recent call last):
    ...
OSError: [Errno 24] Too many open files: 'file-1021.txt'

Данный фрагмент пытается открыть десять тысяч файлов и сохранить их на диске. Но, в итоге ОС выдает ошибку Too many open files, как только лимит одновременно открытых файлов в ней исчерпывается. Более того, реально созданное на диске количество файлов зачастую может и не совпадать с тем, что выдается сообщением об ошибке при сбои вышеприведенной программы.

Рекомендации: С целью предотвращения мешанины среди вновь создаваемых и уже имеющихся файлов на диске, вышеприведенную программу желательно запускать в предварительно созданной директории. Для UNIX-подобных ОС это реализуется следующими командами:

$ mkdir file_experiment
$ cd file_experiment

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

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

Что такое «Файловые дескрипторы» и, для чего они используются

Базовая функция любой ОС состоит в обеспечении посредничества между прикладными программными процессами, такими как Python и, различными системными ресурсами вроде жестких дисков, оперативной памяти и процессорного времени.

Следовательно, открывая на Python определенный файл с помощью функции open(), вы на самом деле осуществляете системный вызов операционной системе, с тем чтобы найти этот файл на информационном носителе, а также подготовить его для чтения или записи. В итоге ОС возвращает в Python целое число без знака, называемое в Windows — file handle, а в UNIX-подобных системах типа Linux и macOS — file descriptor:

Рис. 1. Процесс Python, выполняющий системный вызов и получающий целое число 10 в качестве дескриптора файла.

Впоследствии, полученное вами целое число в виде номера файлового дескриптора должно использоваться программой Python всякий раз, когда ей нужно прочитать, записать или закрыть соответствующий файл. Это делается путем еще одного вызова ОС, где указывается номер соответствующего дескриптора, нужного для работы файла. Хотя непосредственное значение файлового дескриптора для конкретных файлов в виде целого числа редко необходимо в Python программах, его все же можно узнать, воспользовавшись методом файлового объекта — . fileno():

>>> with open("test_file.txt", mode="w") as file:
...     file.fileno()
...
4

Применение механизмов, обеспечивающих своевременное закрытие файлов

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

# write_hello.py
file = open("hello.txt", mode="w")
file.write("Hello, world!")

Python после создания файла hello.txt и записи в него текста ‘Hello, world!’ сам заботиться о том, чтобы этот файл был автоматически закрыт после благополучного завершения программы.

Однако, что, если данная программа не завершится корректно, например, из-за отключения электричества в момент ее выполнения? Смоделируем эту ситуацию программным путем за счет применения функции os. _exit(1), имитирующей сбой программы:

# crash_hello.py
import os
file = open("crash.txt", mode="w")
file.write("Hello, world!")
os._exit(1)

Результат выполнения последнего фрагмента кода можно посмотреть путем вывода содержимого файла ‘ crash.txt’, используя команду cat (для UNIX-систем):

$ cat crash.txt
$ # No output!

Как видим, что хотя вышеназванный файл и был создан ОС, но он оказался пустым.
Таким образом, при написании программ лучше все же закрывать файлы сразу после того, как они были использованы. Это можно сделать путем использования конструкции try… finally:

try:
    file = open("hello.txt", mode="w")
    file.write("Hello, World!")
finally:
    file.close()

Где блок finally безальтернативно закрывает файл ‘hello.txt’ независимо от того, успешно ли был выполнен блок try. Вмести с тем, использования конструкции try… finally для своевременного закрытия файлов является довольно громоздким и трудночитаемым. Гораздо более компактный и интуитивно понятный подход в Python обеспечивается применением так называемого контекстного менеджера, благодаря которому вышеприведенный код выглядит следующим образом:

with open("hello.txt", mode="w") as file:
    file.write("Hello, World!")

Первой строкой в этом коде (оператором with) инициируется контекстный менеджер — блок, все последующие строки которого являются строками с отступом. Как только эти строки с отступом заканчиваются или же при их выполнении вызывается какое-либо исключение, файлы, обрабатываемые в данном контекстном менеджере, закрываются. Таким образом программы, написанные с использованием подобных менеджеров компактны, интуитивно понятны и читабельны.

Выводы

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

Практический Python для начинающих

Станьте junior Python программистом за 7 месяцев

 7 месяцев

Подробнее

Как открыть и закрыть файл в Python

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

Открытие файла в Python

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

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

Синтаксис: File_object = open(«File_Name», «Access_Mode»)

Параметры:  

  • File_Name: Это имя файла, который необходимо открыть.
  • Access_Mode: Режимы доступа определяют тип операций, возможных в открытом файле. В таблице ниже приведен список всех режимов доступа, доступных в Python
Операция Синтаксис Описание
Чтение Только r Открыть текстовый файл только для чтения.
Чтение и запись r+ Открыть файл для чтения и записи.
Только запись w Открыть файл для записи.
Запись и чтение w+ Открыть файл для чтения и записи. В отличие от «r+», это не вызывает ошибку ввода-вывода, если файл не существует.
Добавить только a Открыть файл для записи и создать новый файл, если он не существует. Все дополнения делаются в конце файла, и никакие существующие данные не могут быть изменены.
Добавить и прочитать a+ Открыть файл для чтения и записи и создать новый файл, если он не существует. Все дополнения делаются в конце файла, и никакие существующие данные не могут быть изменены.

Пример 1:  Открыть и прочитать файл с помощью Python

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

Код:

Python3

файл = открыть ( "sample.txt" )

 

печать ( файл . read())

Здесь мы открыли файл и распечатал его содержимое.

Вывод:  

 Привет, Компьютерщик!
Это образец текстового файла для примера.

Пример 2:   Открытие и запись в файл с помощью Python

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

Код:

Python3

файл = открыть ( "sample.txt" , 'a' )

 

файл .write( "Этот текст был недавно добавлен в файл образца" )

Теперь, если вы откроете файл, вы увидите следующий результат:

Вывод:

9010 1 Пример 3:  Открыть и перезаписать файл с помощью Python.

файл = открыть ( "sample.txt" , 'w' )

 

файл .write( "Все содержимое было перезаписано!" )

Приведенный выше код приводит к следующему результату:

Вывод:   9000 3

 

Пример 4. Создание файла, если он не существует в Python

Метод path.touch() модуля pathlib создает файл по пути, указанному в пути path.touch().

Python3

900 48

из pathlib импорт Path

 

my_file = Путь( 'test1/myfile.txt' )

my_file.touch(exist_ok 9 0120 = Правда )

f = открыть (my__file)

Выход:

 

Закрытие файла в Python

Как вы заметили, мы не закрыли ни один из файлов, над которыми мы работали в приведенных выше примерах. Хотя Python автоматически закрывает файл, если ссылочный объект файла выделяется для другого файла, стандартная практика — закрытие открытого файла, поскольку закрытый файл снижает риск необоснованного изменения или чтения.
Python имеет метод close() для закрытия файла. Метод close() можно вызывать более одного раза, и если какая-либо операция выполняется с закрытым файлом, возникает ошибка ValueError. В приведенном ниже коде показано простое использование метода close() для закрытия открытого файла.

Пример:  Прочитайте и закройте файл с помощью Python

Python3

файл = открыть 901 21 ( "sample.txt" )

    

печать ( файл .read())

 

файл .close()

Теперь, если мы попытаемся выполнить какую-либо операцию на закрытый файл, как показано ниже, вызывает ошибку ValueError: 

Python3

файл = открыть ( "sample. txt" )

    

печать ( файл .read())

 

файл .close()

 

файл .write( "Попытка записи в закрытый файл !" 9 0120)

Вывод: 

 ValueError: Операция ввода/вывода в закрытом файле.

Почему важно закрывать файлы в Python? – Real Python

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

 с помощью open("hello.txt", mode="w") в качестве файла:
    file.write("Привет, мир!")

Оператор с оператором инициирует диспетчер контекста. В этом примере диспетчер контекста открывает файл hello. txt и управляет файловым ресурсом, пока активен контекст . В общем, весь код в блоке с отступом зависит от того, какой файловый объект открыт. Как только блок с отступом заканчивается или вызывает исключение, файл закрывается.

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

 попытка:
    файл = открыть ("hello.txt", режим = "w")
    file.write("Привет, мир!")
окончательно:
    файл.закрыть()

Блок finally , который закрывает файл, выполняется безоговорочно, независимо от того, успешен или нет блок try . Хотя этот синтаксис эффективно закрывает файл, менеджер контекста Python предлагает менее подробный и более интуитивно понятный синтаксис. Кроме того, это немного более гибко, чем просто обертывание вашего кода попробовать … наконец .

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

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

Вкратце: файлы — это ресурсы, ограниченные операционной системой

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

Когда вы открываете файл с помощью open() , вы делаете системный вызов в операционную систему, чтобы найти этот файл на жестком диске и подготовить его для чтения или записи. Затем операционная система вернет целое число без знака, называемое 9.дескриптор файла 0005 в Windows и дескриптор файла в UNIX-подобных системах, включая Linux и macOS:

Процесс Python выполняет системный вызов и получает целое число 10 в качестве дескриптора файла

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

>>>

 >>> с open("test_file.txt", mode="w") в качестве файла:
... файл.fileno()
...
4

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

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

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

Примечание : Некоторые библиотеки имеют специальные методы и функции, которые, кажется, открывают файлы без менеджера контекста. Например, в библиотеке pathlib есть .write_text() , а в pandas — read_csv() .

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

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

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